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 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 VocabularyTerm(db.Model):
id = db.Column(db.Integer, primary_key=True)
english = db.Column(db.VARCHAR(255), nullable=False)
french = db.Column(db.ARRAY(db.VARCHAR(255),
dimensions=1,
zero_indexes=True),
nullable=False,
default=[])
antonym = db.Column(db.ARRAY(db.VARCHAR(255),
dimensions=1,
zero_indexes=True),
nullable=False,
default=True)
category_id = db.Column(db.Integer,
db.ForeignKey('vocabulary_category.id'),
nullable=False)
category = db.relationship('VocabularyCategory')
def __init__(self, english, french, antonym, category):
self.english = english
self.french = french
self.antonym = antonym
self.category = category
def __repr__(self):
return f'<VocabTerm {self.english}>'
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 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 BlockListModel(db.Model):
__tablename__ = 'blocklist'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, unique=True)
insert_time = db.Column(db.Float)
def __init__(self, user_id: int, insert_time: float):
self.user_id = user_id
self.insert_time = insert_time
def json(self) -> BlockJSON:
return {self.id: [{'user_id': self.user_id,
'insert_time': convert_timestamp(self.insert_time)}]
}
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_user_id(cls, user_id: int) -> "BlockListModel":
return cls.query.filter_by(user_id=user_id).first()
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 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 VocabularyCategory(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.VARCHAR(255), nullable=False)
terms = db.relationship("VocabularyTerm", backref="vocabulary_category", lazy='dynamic')
def __init__(self, name):
self.name = name
def __repr__(self):
return f'<Category {self.name}>'
class Url(db.Model):
__tablename__ = 'url'
id = db.Column(db.Integer, primary_key=True)
original_url = db.Column(db.Text())
shorted_url = db.Column(db.Text())
created = db.Column(db.Date())
def __init__(self, original_url, shorted_url):
self.original_url = original_url
self.shorted_url = shorted_url
self.created = date.today()
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 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 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 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 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 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 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 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 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 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 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 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 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')
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}
from db.db import db
from db.db import DB_STAFF
from db.db import DB_COURSE
# db.create_all()将自动生成表student_teacher_relationship, student, teacher
student_teacher_relationship = db.Table('student_teacher_relationship',
db.Column('student_id', db.Integer, db.ForeignKey('student.id')),
db.Column('teacher_id', db.Integer, db.ForeignKey('teacher.id')),
info={'bind_key': DB_STAFF}
)
class Student(db.Model):
__bind_key__ = DB_STAFF
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(10))
teachers = db.relationship('Teacher', secondary = student_teacher_relationship, back_populates = 'students')
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')
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()
