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"]