class User(db.Model): __tablename__ = "user" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(30), nullable=False, unique=True) password = db.Column(db.String(30), nullable=False) def __init__(self, username, password): self.username = username self.password = password @classmethod def get_username_by_name(cls, username): return cls.query.filter_by(username=username).first() @classmethod def get_username_by_id(cls, id): return cls.query.filter_by(id=id).first() def create_username(self): db.session.add(self) db.session.commit() def json(self): return { "id": self.id, "username": self.username, "password": self.password }
class UserModel(db.Model): __tablename__ = 'usuers' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80)) password = db.Column(db.String(15)) nivel = db.Column(db.Integer, default="1") def __init__(self, username, password, nivel): self.username = username self.password = password self.nivel = nivel def json(self): return {'id': self.id, 'username': self.username, 'nivel': self.nivel} @classmethod def buscar_por_nome(cls, username): return cls.query.filter_by(username=username).first() @classmethod def buscar_por_id(cls, id): return cls.query.filter_by(id=id).first() def salvar_no_banco(self): db.session.add(self) db.session.commit() def remover_no_banco(self): db.session.delete(self) db.session.commit() def update(self): db.session.commit()
class Person(db.Model): cpf = db.Column(db.String(100), primary_key=True, unique=True, nullable=False) nome = db.Column(db.String(100), unique=False, nullable=False) endereco = db.relationship('Address', uselist=False, backref='person') lista_dividas = db.relationship('Debt', backref='person') @property def serialize(self): return { 'cpf': self.cpf, 'nome': self.nome, 'endereco': { 'rua': self.endereco.rua, 'numero': self.endereco.numero, 'cidade': self.endereco.cidade, 'estado': self.endereco.estado }, 'lista_dividas': [{ 'tipo': divida.tipo, 'valor': divida.valor } for divida in self.lista_dividas] }
class User(db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(30), nullable=False) username = db.Column(db.String(30), nullable=False) psd = db.Column(db.String(30), nullable=False) money = db.Column(db.Float, nullable=False, default=0) create_time = db.Column(db.DATETIME, default=datetime.now)
class Address(db.Model): id = db.Column(db.Integer, primary_key=True) rua = db.Column(db.String(100), unique=True, nullable=True) numero = db.Column(db.Integer, unique=False, nullable=True) cidade = db.Column(db.String(100), unique=False, nullable=True) estado = db.Column(db.String(100), unique=False, nullable=True) person_id = db.Column(db.Integer, db.ForeignKey('person.cpf'), nullable=False)
class Employee(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), nullable=False) email = db.Column(db.String(255), nullable=False) contact = db.Column(db.String(10), nullable=False) addresses = db.relationship('Address', backref=db.backref('employee', uselist=True), cascade='all, delete-orphan', lazy=True, uselist=True)
class User(db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(30), nullable=False) username = db.Column(db.String(30), nullable=False) psd = db.Column(db.String(30), nullable=False) money = db.Column(db.Float, nullable=False, default=0) create_time = db.Column(db.DATETIME, default=datetime.now) def __repr__(self): return '<User(email=%s, username=%s)>' % (self.email, self.username)
class Employee(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), nullable=False) email = db.Column(db.String(255), nullable=False) contact = db.Column(db.String(10), nullable=False) def serialize(self): return { 'name': self.name, 'email': self.email, 'contact': self.contact, 'id': self.id, }
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(20), unique=True) password = db.Column(db.LargeBinary) email = db.Column(db.String(25), unique=True) registered_timestamp = db.Column(db.Float) last_login_timestamp = db.Column(db.Float) activated = db.Column(db.Boolean, default=False) def __init__(self, username: str, email: str, password: str, last_login_timestamp: float): self.username = username self.email = email self.password = encrypt(password) self.last_login_timestamp = last_login_timestamp def json(self) -> UserJSON: return { self.id: [{ 'username': str(encrypt(self.username)), 'email': str(encrypt(self.email)), 'last_login_timestamp ': convert_timestamp(self.last_login_timestamp), 'items': [item.json() for item in ItemModel.find_cart(self.id)] }] } def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit() @classmethod def find_by_username(cls, username: str) -> "UserModel": return cls.query.filter_by(username=username).first() @classmethod def find_by_email(cls, email: str) -> "UserModel": return cls.query.filter_by(email=email).first() @classmethod def find_by_id(cls, _id: int) -> "UserModel": return cls.query.filter_by(id=_id).first()
class Store(db.Model): __tablename__ = 'stores' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) items = db.relationship('Item', lazy='dynamic') def __init__(self, name): self.name = name @classmethod def get_by_name(cls, name: str) -> Dict: return Store.query.filter_by(name=name).first() def error(self, msg: str, code: int) -> Dict: return {'error': msg}, code def as_json(self) -> Dict: return { 'name': self.name, 'items': [item.as_json() for item in self.items.all()] } def save(self) -> None: db.session.add(self) db.session.commit() def delete(self) -> None: db.session.delete(self) db.session.commit()
class DisciplinaModel(db.Model): __tablename__ = 'disciplinas' id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(80)) topicos = db.relationship('TopicoModel', lazy="dynamic") def __init__(self, nome): self.nome = nome def json(self): return { 'id': self.id, 'nome': self.nome, 'topicos': [topico.json() for topico in self.topicos.all()] } @classmethod def buscar_por_nome(cls, nome): return cls.query.filter_by(nome=nome).first() @classmethod def buscar_por_id(cls, id): return cls.query.filter_by(id=id).first() def salvar_no_banco(self): db.session.add(self) db.session.commit() def remover_no_banco(self): db.session.delete(self) db.session.commit()
class Debt(db.Model): id = db.Column(db.Integer, primary_key=True) tipo = db.Column(db.String(100), unique=False, nullable=True) valor = db.Column(db.Integer, unique=False, nullable=True) person_id = db.Column(db.Integer, db.ForeignKey('person.cpf'), nullable=False)
class Address(db.Model): id = db.Column(db.Integer, primary_key=True) addr = db.Column(db.String(255), nullable=False) employee_id = db.Column(db.Integer, db.ForeignKey('employee.id'), unique=True, nullable=False) def __init__(self, addr): self.addr = addr
class PaymentModel(db.Model): __tablename__ = 'payment' id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.String(20)) total_value = db.Column(db.Float(precision=2)) total_quantity = db.Column(db.Integer) payment_timestamp = db.Column(db.Float) receipt = db.Column(db.Integer, autoincrement=True, unique=True) def __init__(self, user_id: int, total_value: float, total_quantity: int, payment_timestamp: float): self.user_id = user_id self.total_value = total_value self.total_quantity = total_quantity self.payment_timestamp = payment_timestamp def json(self) -> PaymentJSON: return { self.id: [{ 'receipt_num': self.receipt, 'user_id': self.user_id, 'total_quantity': self.total_quantity, 'total_value': self.total_value, 'items': [item.json() for item in ItemModel.find_cart(self.id)] }] } @classmethod def find_by_user_id(cls, _id: int) -> "PaymentModel": return cls.query.with_entities( func.sum(convert_timestamp( PaymentModel.payment_timestamp))).filter_by( user_id=_id).first() @classmethod def find_by_receipt(cls, num: int) -> "PaymentModel": return cls.query.filter_by(receipt=num).first() @classmethod def find_all_by_user_id(cls, _id: int) -> "PaymentModel": return cls.query.filter_by(user_id=_id).all() def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class Person(db.Model): cpf = db.Column(db.String(100), primary_key=True, unique=True, nullable=False) nome = db.Column(db.String(100), unique=False, nullable=False) endereco = db.relationship('Address', uselist=False, backref='person') fonte_renda = db.relationship('Income', backref='person') lista_bens = db.relationship('Patrimony', backref='person') @property def score(self): return calc_score(self.fonte_renda, self.lista_bens) @property def serialize(self): return { 'cpf': self.cpf, 'nome': self.nome, 'score': self.score, 'endereco': { 'rua': self.endereco.rua, 'numero': self.endereco.numero, 'cidade': self.endereco.cidade, 'estado': self.endereco.estado }, 'fonte_renda': [{ 'tipo': divida.tipo, 'valor': divida.valor } for divida in self.fonte_renda], 'lista_bens': [{ 'tipo': patrimonio.tipo, 'valor': patrimonio.valor } for patrimonio in self.lista_bens] }
class RelacionamentoModel(db.Model): __tablename__ = 'relacionamentotopicos' id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(150)) topico1_id = db.Column(db.Integer, db.ForeignKey('topicos.id')) topico2_id = db.Column(db.Integer, db.ForeignKey('topicos.id')) topico1 = db.relationship( "TopicoModel", primaryjoin=TopicoModel.id == topico1_id, ) topico2 = db.relationship( "TopicoModel", primaryjoin=TopicoModel.id == topico2_id, ) def __init__(self, nome, topico1_id, topico2_id): self.nome = nome self.topico1_id = topico1_id self.topico2_id = topico2_id def json(self): return { 'id': self.id, 'nome': self.nome, 'id_topico1': self.topico1_id, 'id_topico2': self.topico2_id } @classmethod def buscar_por_nome(cls, nome): return cls.query.filter_by(nome=nome).first() @classmethod def buscar_por_id(cls, id): return cls.query.filter_by(id=id).first() def salvar_no_banco(self): db.session.add(self) db.session.commit() def remover_no_banco(self): db.session.delete(self) db.session.commit()
class StoreModel(db.Model): __tablename__ = 'stores' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(20), unique=True) created_timestamp = db.Column(db.Float) modify_timestamp = db.Column(db.Float) items = db.relationship('ItemModel', lazy='dynamic') def __init__(self, name: str, created_timestamp: float, modify_timestamp: float): self.name = name self.created_timestamp = created_timestamp self.modify_timestamp = modify_timestamp def json(self) -> StoreJSON: return { self.id: [{ 'name': self.name, 'created_at': convert_timestamp(self.created_timestamp), 'last_modified': convert_timestamp(self.modify_timestamp), 'items': [item.json() for item in self.items.all()] }] } @classmethod def find_by_name(cls, name: str) -> "StoreModel": return cls.query.filter_by(name=name).first() @classmethod def find_by_id(cls, _id: str) -> "StoreModel": return cls.query.filter_by(id=_id).first() def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class TopicoModel(db.Model): __tablename__ = 'topicos' id = db.Column(db.Integer, primary_key=True) nome = db.Column(db.String(80)) id_disciplinas = db.Column(db.Integer, db.ForeignKey('disciplinas.id')) disciplina = db.relationship('DisciplinaModel') def __init__(self, nome, id_disciplinas): self.nome = nome self.id_disciplinas = id_disciplinas def json(self): return { 'id': self.id, 'nome': self.nome, 'id_disciplina': self.id_disciplinas } @classmethod def buscar_por_nome(cls, nome): return cls.query.filter_by(nome=nome).first() @classmethod def buscar_por_id(cls, id): return cls.query.filter_by(id=id).first() def salvar_no_banco(self): db.session.add(self) db.session.commit() def remover_no_banco(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)) def __init__(self, name, price): self.name = name self.price = price def json(self): return {'name': self.name, 'price': self.price} @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 Item(db.Model): """ Creates new item objects so create new items for use throughout the API """ __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('Store') def __init__(self, name: str, price: float, store_id: int) -> None: self.name = name self.price = price self.store_id = store_id @classmethod def get_by_name(cls, name: str) -> Dict: return cls.query.filter_by(name=name).first() def as_json(self) -> Dict: return {'name': self.name, 'price': self.price} def get_all(self) -> Dict: return {'items': [self.as_json() for item in Item.query.all()]} def save(self) -> None: db.session.add(self) db.session.commit() def delete(self) -> None: db.session.delete(self) db.session.commit()
class Messages(db.Model): id = db.Column(db.Integer, primary_key=True) message = db.Column(db.String(400)) def serialize(self): return {"id": self.id, "message": self.message}
class Message(db.Model): __tablename__ = "message" id = db.Column(db.Integer, primary_key=True) sender_id = db.Column(db.Integer, db.ForeignKey('user.id')) receiver_id = db.Column(db.Integer, db.ForeignKey('user.id')) message = db.Column(db.String(300)) subject = db.Column(db.String(30)) creation_date = db.Column(db.DateTime, default=datetime.now) read = db.Column(db.Boolean, default=False) def __init__(self, sender_id, receiver_id, message, subject): self.sender_id = sender_id self.receiver_id = receiver_id self.message = message self.subject = subject self.creation_date = datetime.now() self.read = False def create_message(self): db.session.add(self) db.session.commit() @classmethod def get_message_by_id(cls, id): return cls.query.filter_by(receiver_id=id).all() @classmethod def get_unread_message_by_id(cls, id): return cls.query.filter(and_(cls.receiver_id == id, cls.read == False)).all() @classmethod def read_message(cls, id): first_message = Message.query.filter( and_(cls.receiver_id == id, cls.read == False)).first() first_message.read = True db.session.commit() return first_message @classmethod def delete_message(cls, id, message_id): message = cls.query.filter_by(id=message_id).first() try: if id == message.receiver_id or id == message.sender_id: db.session.delete(message) db.session.commit() return True except Exception as e: return False return False def json(self): return { "sender_id": self.sender_id, "receiver_id": self.receiver_id, "subject": self.subject, "message": self.message, "creation_date": self.creation_date.isoformat(), "read": self.read }
class Profile(db.Model): id = db.Column(db.Integer, primary_key=True) img_name = db.Column(db.String(255), nullable=False) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False)
class ItemModel(db.Model): __tablename__ = 'items' id = db.Column(db.Integer, primary_key=True, autoincrement=True) item_name = db.Column(db.String(20)) price = db.Column(db.Float(precision=2)) created_timestamp = db.Column(db.Float) modify_timestamp = db.Column(db.Float) store_id = db.Column(db.Integer, db.ForeignKey('stores.id')) store = db.relationship('StoreModel') user_id = db.Column(db.Integer) def __init__(self, item_name: str, price: float, modify_timestamp: float): self.item_name = item_name self.price = price self.modify_timestamp = modify_timestamp def json(self) -> ItemJSON: return { self.id: [{ 'item_name': self.item_name, 'price': self.price, 'store': self.store_id, 'last_modified': convert_timestamp(self.modify_timestamp) }] } def all_items_json(self) -> ALLItemJSON: return { self.id: [{ 'item_name': self.item_name, 'price': self.price, 'store': self.store_id, 'hold_by_user': self.user_id, 'last_modified': convert_timestamp(self.modify_timestamp) }] } @classmethod def find_by_name(cls, item_name: str) -> "ItemModel": return cls.query.filter_by(item_name=item_name).first() @classmethod def find_by_id(cls, _id: int) -> "ItemModel": return cls.query.filter_by(id=_id).first() @classmethod def find_cart(cls, _id: int) -> "ItemModel": return cls.query.filter_by(user_id=_id).all() @classmethod def find_stock(cls) -> "ItemModel": return cls.query.filter(cls.store_id != None, cls.user_id == None).all() @classmethod def update_user_id(cls, _id: int) -> "ItemModel": return cls.query.filter_by(user_id=_id).update(dict(user_id=None)) return item.all() @classmethod def sum_cart_by_user_id(cls, _id: int) -> "ItemModel": tot = cls.query.with_entities(func.sum(ItemModel.price)). \ filter_by(user_id=_id).all() print(tot[0][0]) if tot[0][0] is None: return 0 return tot[0][0] @classmethod def count_cart_by_user_id(cls, _id: int) -> "ItemModel": tot = cls.query.with_entities(func.count(ItemModel.price)). \ filter_by(user_id=_id).all() if tot[0][0] is None: return 0 return tot[0][0] def save_to_db(self) -> None: db.session.add(self) db.session.commit() def delete_from_db(self) -> None: db.session.delete(self) db.session.commit()
class Teacher(db.Model): __bind_key__ = DB_STAFF id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(10)) students = db.relationship('Student', secondary = student_teacher_relationship, back_populates = 'teachers')