class Todo(db.Model):
__tablename__ = 'todo'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
def __init__(self, name):
self.name = name
def __repr__(self):
return '<id {0}>'.format(self.id)
def save(self):
db.session.add(self)
db.session.commit()
return self
# FIXME: Validar si se obtiene un objeto
def delete(self):
db.session.delete(self)
db.session.commit()
return self
def to_dict(self):
return {
c.key: getattr(self, c.key)
for c in inspect(self).mapper.column_attrs
}
class GroupTable(db.Model):
__tablename__ = "grouptable"
groupid = db.Column(UUID(as_uuid=True), primary_key=True)
groupname = db.Column(db.String(64), nullable=False)
groupleaderid = db.Column('groupleader',
UUID(as_uuid=True),
db.ForeignKey('usertable.userid'),
nullable=False)
groupleader = db.relationship(UserTable,
foreign_keys=groupleaderid,
backref=db.backref('leader', lazy='joined'))
def __init__(self, data):
self.groupid = str(uuid.uuid1())
self.groupname = data["groupname"]
self.groupleaderid = data["groupleaderid"]
def serialise(self):
return {
"groupid": str(self.groupid),
"groupname": str(self.groupname),
"groupleaderid": str(self.groupleaderid)
}
class StoreModel(db.Model):
__tablename__ = 'stores'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.relationship('ItemModel', lazy='dynamic')
def __init__(self, name):
self.name = name
def json(self):
return {
'name': self.name,
'items': [item.json() for item in self.items.all()]
}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@classmethod
def find_all(cls):
return cls.query.all()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class LibraryModel(db.Model):
__tablename__ = "libraries"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
books = db.relationship('BookModel', lazy='dynamic')
def __init__(self, name):
self.name = name
def json(self):
return {
'id': self.id,
'name': self.name,
'items': [item.json() for item in self.books.all()]
}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
store = db.relationship('StoreModel')
def __init__(self, name, price, store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {'id': self.id, 'name': self.name, 'price': self.price, 'store_id': self.store_id}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class StoreModel(db.Model):
__tablename__ = 'stores'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80)) # 80 characters limit
# List of ItemModels; many-to-1 rel. (Back reference)
# lazy: to not create an StoreModel for each item yet
items = db.relationship(
'ItemModel', lazy='dynamic'
) # self.items is no list anymore but a query builder -> .all()
def __init__(self, name):
self.name = name
def json(self) -> dict:
"""
Returns the name & items as .json string.
:return: {'id': Int, 'name': String, 'items': String}
"""
return {
'id': self.id,
'name': self.name,
'items': [item.json() for item in self.items.all()]
} # List comprehension
@classmethod
def find_by_name(cls, name: str) -> object:
"""
Find an object by its name.
:param name: Item name to find.
:return: object
"""
return cls.query.filter_by(
name=name).first() # SELECT * FROM items WHERE name=name LIMIT 1
@classmethod
def find_all(cls) -> tuple:
"""
Returns all stores in .db
:return: All stores found in .db
"""
return cls.query.all()
def save_to_db(self) -> None:
"""
Insert new or update existing object in data base.
"""
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
"""
Delete object from the data base.
"""
db.session.delete(self)
db.session.commit()
class StoreModel(db.Model):
__tablename__ = "tblStores"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
# knows it is a many to one relationship , so this is a list
items = db.relationship('ItemModel', lazy='dynamic')
def __init__(self, name):
self.name = name
def json(self):
return {
"name": self.name,
"items": [item.json() for item in self.items.all()]
}
def check_empty(self):
return next((item.json() for item in self.items.all()), None)
@classmethod
def find_by_name(cls, name):
return StoreModel.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class UserModel(db.Model):
__tabelname__ = 'users'
id = db.Column(db.Integer,primary_key=True)
username = db.Column(db.String)
password = db.Column(db.String)
def __init__(self,username,password):
# self.id = _id
self.username = username
self.password = password
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls,username):
return cls.query.filter_by(username=username).first()
# connection = sqlite3.connect('mydata.db')
# cursor = connection.cursor()
#
# query = "select * from users where username=?"
# result = cursor.execute(query,(username,))
# row = result.fetchone()
# if row:
# user = cls(*row)
# else:
# user = None
#
# connection.close()
# return user
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class WeatherData(db.Model):
__tablename__ = 'weather_data'
id = db.Column(db.Integer, primary_key=True)
created = db.Column(
db.DateTime,
default=datetime.datetime.now(
pytz.timezone("Europe/Bratislava")).replace(microsecond=0))
temperature = db.Column(db.String())
humidity = db.Column(db.String())
def __init__(self, humidity, temperature, created):
self.humidity = humidity
self.temperature = temperature
self.created = created
def json(self):
return {
"created": self.created,
"temperature": self.temperature,
"humidity": self.humidity,
}
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def save_to_db(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_data_between_specific_dates(start=None, end=None):
try:
if start and end:
data = WeatherData.query.filter(
WeatherData.created <= end).filter(
WeatherData.created >= start)
return data
return {"msg": "Please define START and END dates properly"}, 404
except Exception as e:
return {
"msg": "Could not get required dates. {error}".format(error=e)
}, 500
@classmethod
def find_latest(cls):
return cls.query.order_by(cls.created.desc()).first()
@classmethod
def get_all_available_data(cls):
"""
:return:
"""
try:
weather_data = cls.query.all()
return weather_data
except Exception as e:
print("Could not return weather data: {error}".format(error=e))
return None
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
password = db.Column(db.String(80))
def __init__(self, username, password):
self.username = username
self.password = password
def json(self):
return {
'id':self.id,
'username':self.username
}
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class CommentReadTable(db.Model):
__tablename__ = "commentreadtable"
userid = db.Column('userid',
UUID(as_uuid=True),
db.ForeignKey('usertable.userid', ondelete='CASCADE'),
primary_key=True)
commentid = db.Column('commentid',
UUID(as_uuid=True),
db.ForeignKey('commenttable.commentid',
ondelete='CASCADE'),
primary_key=True)
user = db.relationship(UserTable,
foreign_keys=userid,
backref=db.backref('commenter',
lazy='joined',
cascade="all, delete-orphan"))
comment = db.relationship(CommentTable,
foreign_keys=commentid,
backref=db.backref('commented',
lazy='joined',
cascade="all, delete-orphan"))
def __init__(self, data):
self.commentid = data["commentid"]
self.userid = data["userid"]
class UserModel(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(25), unique=True, nullable=False)
password = db.Column(db.String(25), nullable=False)
def __init__(self, username=None, password=None):
self.username = username
self.password = password
@classmethod
def find_by_username(cls, username: str) -> object:
"""
Find an user by the given username.
:param username: Username to search for the user.
:return: Object of the User class.
"""
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, id_: str) -> object:
"""
Find a user by the given id.
:param id_: ID to search for the user.
:return: Object of the User class.
"""
return cls.query.get(id_)
def save_to_db(self) -> None:
"""
Save to data base.
"""
db.session.add(self)
db.session.commit()
class CommentTable(db.Model):
__tablename__ = "commenttable"
commentid = db.Column(UUID(as_uuid=True), primary_key=True)
fileid = db.Column(UUID(as_uuid=True),
db.ForeignKey('filetable.fileid', ondelete='CASCADE'),
nullable=False)
userid = db.Column(UUID(as_uuid=True),
db.ForeignKey('usertable.userid', ondelete='CASCADE'),
nullable=False)
comment = db.Column(db.String(256), nullable=False)
date = db.Column(db.DateTime())
user = db.relationship(UserTable,
foreign_keys=userid,
backref=db.backref('user',
lazy='joined',
cascade="all, delete-orphan"))
commentFile = db.relationship(FileTable,
foreign_keys=fileid,
backref=db.backref(
'commentFile',
lazy='joined',
cascade="all, delete-orphan"))
def __init__(self, data):
self.commentid = str(uuid.uuid1())
self.fileid = data['fileid']
self.userid = data['userid']
self.comment = data['comment']
self.date = data['date']
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(18), nullable=False, unique=True)
password_hash = db.Column(db.String(94))
# Required for administrative interface
def __unicode__(self):
return self.username
class CourseTheme(db.Model):
__tablename__ = 'course_themes'
id = db.Column(UUID,
server_default=db.text('gen_random_uuid()'),
primary_key=True)
name = db.Column(db.VARCHAR(255))
course_number = db.relationship('CourseNumber')
course_number_lazy = db.relationship('CourseNumber', lazy='dynamic')
class Teacher(db.Model):
__tablename__ = 'teachers'
id = db.Column(UUID,
server_default=db.text('gen_random_uuid()'),
primary_key=True)
name = db.Column(db.VARCHAR(255))
email = db.Column(db.VARCHAR(255))
subjects = db.relationship('Subject')
class EventLog(db.Model):
__tablename__ = 'event_log'
id = db.Column(UUID,
server_default=db.text('gen_random_uuid()'),
primary_key=True)
msg = db.Column(db.VARCHAR(255))
course_number_id = db.Column(UUID, db.ForeignKey('course_numbers.id'))
course_number = db.relationship('CourseNumber')
class ItemModel(db.Model):
__tabelname__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
# store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
# store = db.relationship('StoreModel')
def __init__(self, name, price):
self.name = name
self.price = price
# self.store_id = store_id
def json(self):
return {'name':self.name,'price':self.price}
@classmethod
def find_by_name(cls,name):
# connection = sqlite3.connect('mydata.db')
# cursor = connection.cursor()
#
# query = "select * from items where name=?"
# result = cursor.execute(query, (name,))
# row = result.fetchone()
# connection.close()
#
# if row:
# return cls(*row) # cls(row[0],row[1])
return ItemModel.query.filter_by(name=name).first()
def save_to_db(self): # def insert(self):
# connection = sqlite3.connect('mydata.db')
# cursor = connection.cursor()
# query = "insert into items values(?,?)"
# cursor.execute(query, (self.name, self.price,))
# connection.commit()
# connection.close()
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
# def update(self):
# connection = sqlite3.connect('mydata.db')
# cursor = connection.cursor()
# query = "update items set price=? where name=?"
# cursor.execute(query, (self.price, self.name,))
# connection.commit()
# connection.close()
class FileTable(db.Model):
__tablename__ = "filetable"
fileid = db.Column(UUID(as_uuid=True), primary_key=True)
filename = db.Column(db.String(64), nullable=False)
extension = db.Column(db.String(16), nullable=False)
def __init__(self, data):
self.fileid = str(uuid.uuid1())
self.filename = data["filename"]
self.extension = data["extension"]
class StoreModel(db.Model):
__tabelname__ = 'stores'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.relationship("ItemModel", back_populates="items")
items = db.relationship('ItemModel', lazy='dynamic')
def __init__(self, name):
self.name = name
def json(self):
return {'name':self.name,'items':[item.json() for item in self.items.all()]}
@classmethod
def find_by_name(cls,name):
# connection = sqlite3.connect('mydata.db')
# cursor = connection.cursor()
#
# query = "select * from items where name=?"
# result = cursor.execute(query, (name,))
# row = result.fetchone()
# connection.close()
#
# if row:
# return cls(*row) # cls(row[0],row[1])
#return ItemModel.query.filter_by(name=name).first()
return cls.query.filter_by(name=name).first()
def save_to_db(self): # def insert(self):
# connection = sqlite3.connect('mydata.db')
# cursor = connection.cursor()
# query = "insert into items values(?,?)"
# cursor.execute(query, (self.name, self.price,))
# connection.commit()
# connection.close()
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
# def update(self):
# connection = sqlite3.connect('mydata.db')
# cursor = connection.cursor()
# query = "update items set price=? where name=?"
# cursor.execute(query, (self.price, self.name,))
# connection.commit()
# connection.close()
class Cardiaque(OutputMixin, db.Model):
__tablename__ = 'cardiaque'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(), nullable=False)
rythme = db.Column(db.Integer, primary_key=False)
date = db.Column(db.Text, nullable=True)
#rythme cardiaque enregistré
def __repr__(self):
return "{{'id' : '{}', 'email' : '{}', 'rythme' : '{}', 'date' : '{}'}}" \
.format(self.id, self.email, self.rythme, self.date)
class Image(db.Model, Serializer):
id = db.Column(db.String(36),
primary_key=True,
default=generate_uuid,
unique=True)
image_url = db.Column(db.String())
license = db.Column(db.String())
creator = db.Column(db.String())
def __repr__(self):
return self.image_url.split("/")[-1]
class CourseGroup(db.Model):
__tablename__ = 'course_groups'
id = db.Column(UUID,
server_default=db.text('gen_random_uuid()'),
primary_key=True)
gid = db.Column(db.VARCHAR(30))
course_number_id = db.Column(UUID, db.ForeignKey('course_numbers.id'))
course_number = db.relationship('CourseNumber')
students = db.relationship('User')
class_schedule = db.relationship('ClassSchedule', lazy='dynamic')
class Character(db.Model, Serializer):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(80), unique=True, nullable=False)
collection_id = db.Column(
db.Integer,
db.ForeignKey('collection.id', name='collection_id_character'))
image_id = db.Column(db.String(36),
db.ForeignKey('image.id', name='image_id_character'))
image = db.relationship('Image', uselist=False, foreign_keys=[image_id])
def __repr__(self):
return '{}'.format(self.name)
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80)) # 80 characters limit
password = db.Column(db.String(80))
def __init__(self, username, password):
self.username = username
self.password = password
def json(self) -> dict:
"""
Returns the id & name as .json string.
:return: {'id': Int, 'username': String}
"""
return {'id': self.id, 'username': self.username}
@classmethod
def find_by_username(cls, username: str) -> object:
"""
Find an (already registered) user by the given username.
:param username: Username to search for the user.
:return: Object of the User class.
"""
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, id_: str) -> object:
"""
Find a (already registered) use by the given id.
:param id_: ID to search for the user.
:return: Object of the User class.
"""
return cls.query.get(id_)
def save_to_db(self) -> None:
"""
Save user to data base.
"""
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
"""
Delete user from database.
"""
db.session.delete(self)
db.session.commit()
class UserModel(Model, db.Model):
'''UserModel class
Inherits Model base class and db.Model.
'''
__tablename__ = 'users'
username = db.Column(db.String(32), index=True)
password = db.Column(db.String(128))
site_location = db.Column(db.String(80))
admin = db.Column(db.Boolean)
super_user = db.Column(db.Boolean)
def __init__(self, username, password, site_location, admin, super_user,
created_by):
'''Mapping from DB to UserModel object occurs in init.'''
Model.__init__(self, created_by)
self.username = username
self.password = password
self.site_location = site_location
self.admin = admin
self.super_user = super_user
def save_to_db(self):
'''Save user record to DB.'''
db.session.add(self)
db.session.commit()
def delete_from_db(self):
'''Delete user record from DB.'''
db.session.delete(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
'''Returns user if found by name'''
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id):
'''Returns user if found by ID.'''
return cls.query.filter_by(id=_id).first()
def json(self):
'''Returns JSON object of user.'''
return {
'username': self.username,
'password': self.password,
'site_location': self.site_location,
'admin': self.admin,
'super_user': self.super_user
}
class Model():
'''Base Model class for all other models
'''
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
last_updated_by = db.Column(db.String)
def __init__(self, created_by):
'''DB auditing variables are mapped during init.'''
self.created_at = datetime.now()
self.updated_at = datetime.now()
self.last_updated_by = created_by
class CourseNumber(db.Model):
__tablename__ = 'course_numbers'
id = db.Column(UUID,
server_default=db.text('gen_random_uuid()'),
primary_key=True)
number = db.Column(db.INTEGER, default=0)
course_theme_id = db.Column(UUID, db.ForeignKey('course_themes.id'))
course_theme = db.relationship('CourseTheme')
course_group = db.relationship('CourseGroup')
subjects = db.relationship('Subject',
secondary=course_number_subjects,
lazy='dynamic')
class Comment(Base):
__tablename__ = "comments"
content = db.Column(db.Text, nullable=False)
product_id = db.Column(db.Integer, db.ForeignKey("products.id", ondelete="CASCADE"), nullable=False)
user_id = db.Column(Base.get_user_id_field(), db.ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
user = db.relationship("User", passive_deletes=True, lazy="joined")
# This relation is only used for cascading deletes, sqlalchemy requires backref relation for cascading deletes to work :/
product = db.relationship("Product", passive_deletes=True, lazy="select")
def __init__(self, content, product_id, user_id):
self.content = content
self.product_id = product_id
self.user_id = user_id
class FileGroupTable(db.Model):
__tablename__ = "filegrouptable"
fileid = db.Column(UUID(as_uuid=True),
db.ForeignKey('filetable.fileid', ondelete='CASCADE'),
primary_key=True)
groupid = db.Column(UUID(as_uuid=True),
db.ForeignKey('grouptable.groupid',
ondelete='CASCADE'),
primary_key=True)
def __init__(self, data):
self.groupid = data["groupid"]
self.fileid = data["fileid"]
