class Post(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
content = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'),nullable=False)
def __repr__(self):
return "'{0}' {1}".format(self.title,self.content)
class User(BaseModel):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),nullable=False, default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post',backref='author',lazy=True)
def __repr__(self):
return "'{0}' {1}".format(self.username,self.email)
class Teams(BaseModel):
Id_Team = db.Column(db.Integer, primary_key=True)
Id_Club = db.Column(db.Integer,
db.ForeignKey('clubs.Id_Club'),
nullable=False,
unique=False)
Name = db.Column(db.String(100), nullable=False)
Date_Of = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
Date_To = db.Column(db.DateTime, nullable=True)
members = db.relationship('Members', backref='members', lazy=True)
_default_fields = [
"Id_Team", "Id_Club", "Name", "Date_Of", "Date_To", "members"
]
def __repr__(self):
return "'{0}'".format(self.Name)
class Members(BaseModel):
Id_Member = db.Column(db.Integer, primary_key=True)
Id_Person = db.Column(db.Integer, db.ForeignKey('persons.Id_Person'),nullable=False)
Id_Club = db.Column(db.Integer, db.ForeignKey('clubs.Id_Club'),nullable=False)
Id_Team = db.Column(db.Integer, db.ForeignKey('teams.Id_Team'),nullable=False)
Date_Of = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
Nickname = db.Column(db.String(50), nullable=True)
Date_To = db.Column(db.DateTime, nullable=True)
Id_Position = db.Column(db.Integer, db.ForeignKey('positions.Id_Position'),nullable=False)
person = db.relationship('Persons', uselist=False)
position = db.relationship('Positions',uselist=False)
def __repr__(self):
return "'{0}'".format(self.Id_Member)
class Persons(BaseModel):
Id_Person = db.Column(db.Integer, primary_key=True)
First_name = db.Column(db.String(50), nullable=False)
Second_name = db.Column(db.String(50), nullable=True)
Surname = db.Column(db.String(50), nullable=False)
Email = db.Column(db.String(120), nullable=True)
Photo = db.Column(db.LargeBinary(length=(2**32) - 1))
#photo_data = db.Column(db.LargeBinary,nullable=True)
Height = db.Column(db.Float, nullable=True)
Weight = db.Column(db.Float, nullable=True)
_default_fields = [
"Id_person", "First_name", "Second_name", "Surname", "Email", "Height",
"Weight"
]
def __repr__(self):
return "'{0}' {1}".format(self.first_name, self.second_name)
class Events(BaseModel):
Id_Event = db.Column(db.Integer, primary_key=True)
Id_Team = db.Column(db.Integer,
db.ForeignKey('teams.Id_Team'),
nullable=False)
Id_Batch = db.Column(db.Integer, nullable=True)
Subject = db.Column(db.String(100), nullable=False)
Description = db.Column(db.String(4000), nullable=True)
Date_Start = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
Date_End = db.Column(db.DateTime, nullable=True)
_default_fields = [
"Id_Event", "Id_Team", "Id_Batch", "Subject", "Description",
"Date_Start", "Date_End"
]
class Clubs(BaseModel):
Id_Club = db.Column(db.Integer, primary_key=True)
Name = db.Column(db.String(100), nullable=False)
#logo = db.Column(db.String(20),nullable=True, default='default.jpg')
Logo = db.Column(db.LargeBinary(length=(2**32) - 1))
Since = db.Column(db.Integer, nullable=True)
Date_Of = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
Date_To = db.Column(db.DateTime, nullable=True)
teams = db.relationship('Teams', backref='teams', lazy=True)
_default_fields = [
"Id_Club", "Name", "Since", "Date_Of", "Date_To", "teams"
]
def __repr__(self):
return "'{0}' '{1}' {2} {3}".format(self.Name, self.Since,
self.Date_Of, self.Date_To)
class BaseModel(db.Model):
__abstract__ = True
UID = db.Column(GUID(), nullable=False, unique=True)
def __init__(self, **kwargs):
kwargs["_force"] = True
self.from_dict(**kwargs)
def to_dict(self, show=None, _hide=[], _path=None):
"""Return a dictionary representation of this model."""
show = show or []
hidden = self._hidden_fields if hasattr(self, "_hidden_fields") else []
default = self._default_fields if hasattr(self,
"_default_fields") else []
default.extend(['id', 'modified_at', 'created_at'])
if not _path:
_path = self.__tablename__.lower()
def prepend_path(item):
item = item.lower()
if item.split(".", 1)[0] == _path:
return item
if len(item) == 0:
return item
if item[0] != ".":
item = ".%s" % item
item = "%s%s" % (_path, item)
return item
_hide[:] = [prepend_path(x) for x in _hide]
show[:] = [prepend_path(x) for x in show]
columns = self.__table__.columns.keys()
relationships = self.__mapper__.relationships.keys()
properties = dir(self)
ret_data = {}
for key in columns:
if key.startswith("_"):
continue
check = "%s.%s" % (_path, key)
if check in _hide or key in hidden:
continue
if check in show or key in default:
if isinstance(getattr(self, key), (datetime, date)):
ret_data[key] = getattr(self, key).isoformat()
else:
ret_data[key] = getattr(self, key)
for key in relationships:
if key.startswith("_"):
continue
check = "%s.%s" % (_path, key)
if check in _hide or key in hidden:
continue
if check in show or key in default:
_hide.append(check)
is_list = self.__mapper__.relationships[key].uselist
if is_list:
items = getattr(self, key)
if self.__mapper__.relationships[
key].query_class is not None:
if hasattr(items, "all"):
items = items.all()
ret_data[key] = []
for item in items:
ret_data[key].append(
item.to_dict(
show=list(show),
_hide=list(_hide),
_path=("%s.%s" % (_path, key.lower())),
))
else:
if (self.__mapper__.relationships[key].query_class
is not None or
self.__mapper__.relationships[key].instrument_class
is not None):
item = getattr(self, key)
if item is not None:
ret_data[key] = item.to_dict(
show=list(show),
_hide=list(_hide),
_path=("%s.%s" % (_path, key.lower())),
)
else:
ret_data[key] = None
else:
ret_data[key] = getattr(self, key)
for key in list(set(properties) - set(columns) - set(relationships)):
if key.startswith("_"):
continue
if not hasattr(self.__class__, key):
continue
attr = getattr(self.__class__, key)
if not (isinstance(attr, property)
or isinstance(attr, QueryableAttribute)):
continue
check = "%s.%s" % (_path, key)
if check in _hide or key in hidden:
continue
if check in show or key in default:
val = getattr(self, key)
if hasattr(val, "to_dict"):
ret_data[key] = val.to_dict(show=list(show),
_hide=list(_hide),
_path=("%s.%s" %
(_path, key.lower())))
else:
try:
if isinstance(val, (datetime, date)):
ret_data[key] = val.isoformat()
else:
ret_data[key] = json.loads(
json.dumps(val, default=json_serial))
except:
pass
return ret_data
def from_dict(self, **kwargs):
"""Update this model with a dictionary."""
_force = kwargs.pop("_force", False)
readonly = self._readonly_fields if hasattr(
self, "_readonly_fields") else []
if hasattr(self, "_hidden_fields"):
readonly += self._hidden_fields
readonly += ["id", "created_at", "modified_at"]
columns = self.__table__.columns.keys()
relationships = self.__mapper__.relationships.keys()
properties = dir(self)
changes = {}
for key in columns:
if key.startswith("_"):
continue
allowed = True if _force or key not in readonly else False
exists = True if key in kwargs else False
if allowed and exists:
val = getattr(self, key)
if val != kwargs[key]:
changes[key] = {"old": val, "new": kwargs[key]}
setattr(self, key, kwargs[key])
for rel in relationships:
if key.startswith("_"):
continue
allowed = True if _force or rel not in readonly else False
exists = True if rel in kwargs else False
if allowed and exists:
is_list = self.__mapper__.relationships[rel].uselist
if is_list:
valid_ids = []
query = getattr(self, rel)
cls = self.__mapper__.relationships[rel].argument()
for item in kwargs[rel]:
if ("id" in item and query.filter_by(
id=item["id"]).limit(1).count() == 1):
obj = cls.query.filter_by(id=item["id"]).first()
col_changes = obj.from_dict(**item)
if col_changes:
col_changes["id"] = str(item["id"])
if rel in changes:
changes[rel].append(col_changes)
else:
changes.update({rel: [col_changes]})
valid_ids.append(str(item["id"]))
else:
col = cls()
col_changes = col.from_dict(**item)
query.append(col)
db.session.flush()
if col_changes:
col_changes["id"] = str(col.id)
if rel in changes:
changes[rel].append(col_changes)
else:
changes.update({rel: [col_changes]})
valid_ids.append(str(col.id))
# delete rows from relationship that were not in kwargs[rel]
for item in query.filter(not_(
cls.id.in_(valid_ids))).all():
col_changes = {"id": str(item.id), "deleted": True}
if rel in changes:
changes[rel].append(col_changes)
else:
changes.update({rel: [col_changes]})
db.session.delete(item)
else:
val = getattr(self, rel)
if self.__mapper__.relationships[
rel].query_class is not None:
if val is not None:
col_changes = val.from_dict(**kwargs[rel])
if col_changes:
changes.update({rel: col_changes})
else:
if val != kwargs[rel]:
setattr(self, rel, kwargs[rel])
changes[rel] = {"old": val, "new": kwargs[rel]}
for key in list(set(properties) - set(columns) - set(relationships)):
if key.startswith("_"):
continue
allowed = True if _force or key not in readonly else False
exists = True if key in kwargs else False
if allowed and exists and getattr(self.__class__,
key).fset is not None:
val = getattr(self, key)
if hasattr(val, "to_dict"):
val = val.to_dict()
changes[key] = {"old": val, "new": kwargs[key]}
setattr(self, key, kwargs[key])
return changes
class Positions(BaseModel):
Id_Position = db.Column(db.Integer, primary_key=True)
Name = db.Column(db.String(50), nullable=False)
def __repr__(self):
return "'{0}'".format(self.Name)
