class Vendedor(db.Model):
idvendedor = db.Column(db.Integer, primary_key=True)
dni = db.Column(db.Integer, nullable=False, unique=True)
email = db.Column(db.String(200), nullable=True, unique=True)
password = db.Column(db.String(250), nullable=False)
nombre = db.Column(db.String(250))
apellidos = db.Column(db.String(250))
telefono = db.Column(db.String(250))
banco = db.Column(db.String(250))
nro_cuenta = db.Column(db.String(250))
nro_cuenta_int = db.Column(db.String(250))
activo = db.Column(db.String(2))
relacionuservet = db.relationship('Uservet', backref='vendedor', lazy=True)
relacionpagovendedor = db.relationship('PagoVendedor',
backref='vendedor',
lazy=True)
def __init__(self, dni, email, password, nombre, apellidos, telefono,
banco, nro_cuenta, nro_cuenta_int, activo):
self.dni = dni
self.email = email
self.password = password
self.nombre = nombre
self.apellidos = apellidos
self.telefono = telefono
self.banco = banco
self.nro_cuenta = nro_cuenta
self.nro_cuenta_int = nro_cuenta_int
self.activo = activo
class Usuario(db.Model):
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.String(255))
email = db.Column(db.String(120),unique = True)
phone = db.Column(db.Integer, nullable = True)
pais = db.Column(db.String(200) , nullable = True)
provincia = db.Column(db.String(200) , nullable = True)
ciudad = db.Column(db.String(200) , nullable = True)
distrito = db.Column(db.String(200) , nullable = True)
direccion = db.Column(db.String(200) , nullable = True)
role = db.Column(db.Integer)
pets = db.relationship('Pet',backref='pet_id')
uservets = db.relationship('UserVet',backref='pet_id')
fecha_registro = db.Column(db.DateTime,default=datetime.utcnow)
auth0id = db.Column(db.String(255))
def __init__(self,name,email,phone,pais,provincia,ciudad,distrito,direccion,role,fecha_registro,auth0id):
self.name = name
self.email = email
self.phone = phone
self.pais = pais
self.provincia = provincia
self.ciudad = ciudad
self.distrito = distrito
self.direccion = direccion
self.role = role
self.fecha_registro= fecha_registro
self.auth0id = auth0id
class ChatbotModel(db.Model):
__tablename__ = "chatbots"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user = db.relationship("UserModel")
intents = db.relationship("IntentModel", lazy="dynamic")
def __init__(self, user_id, name):
self.user_id = user_id
self.name = name
def json(self):
return {
"id": self.id,
"user_id": self.user_id,
"name": self.name,
"intents": [i.json() for i in self.intents.all()],
}
@classmethod
def get_all(cls, user_id):
return cls.query.filter_by(user_id=user_id)
@classmethod
def get_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save(self):
db.session.add(self)
db.session.commit()
class Veterinaria(db.Model):
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.String(255))
logo = db.Column(db.String(255))
ruc = db.Column(db.String(25))
telefono = db.Column(db.String(25))
whatsapp = db.Column(db.String(25))
pais = db.Column(db.String(200))
provincia = db.Column(db.String(200))
ciudad = db.Column(db.String(200))
Distrito = db.Column(db.String(200))
Address = db.Column(db.String(250))
status = db.Column(db.Integer,nullable = False)
fecha_registro = db.Column(db.DateTime,default=datetime.utcnow)
uservets = db.relationship('UserVet',backref='uservetid')
services = db.relationship('Services',backref='serviceid')
def __init__(self,name,logo,ruc,telefono,whatsapp,pais,provincia,ciudad,Distrito,Address,status,fecha_registro):
self.name = name
self.logo = logo
self.ruc = ruc
self.telefono = telefono
self.whatsapp = whatsapp
self.pais = pais
self.provincia = provincia
self.ciudad = ciudad
self.Distrito = Distrito
self.Address = Address
self.status = status
self.fecha_registro =fecha_registro
class StoreModel(db.Model):
__tablename__ = "store"
storeId = db.Column(
db.String(80), primary_key=True
) # prefix ST_ + Serial + registerDate(from UserModel) + userId
storeName = db.Column(db.String(40), nullable=False)
storeLocation = db.Column(db.Text, nullable=True)
storeCoverImage = db.Column(db.Text, nullable=True)
storePicture = db.Column(db.Text, nullable=True)
createDate = db.Column(db.BigInteger, default=time)
updateDate = db.Column(db.BigInteger, onupdate=time)
userId = db.Column(db.String(50), db.ForeignKey('users.userId'))
user = db.relationship('UserModel')
product = db.relationship('ProductModel',
lazy="dynamic",
cascade="all ,delete-orphan")
@classmethod
def fetchAll(cls):
return cls.query.all()
@classmethod
def findSerial(cls):
return cls.query.count()
@classmethod
def findByStoreId(cls, storeid):
return cls.query.filter_by(storeId=storeid).first()
@classmethod
def findByUserId(cls, userid):
return cls.query.filter_by(userId=userid).first()
@classmethod
def isLimit(cls, userid) -> bool:
return cls.query.filter_by(userId=userid).count() >= 5
@classmethod
def findByStoreName(cls, storename):
return cls.query.filter_by(storeName=storename).first()
def insert(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class HospitalModel(db.Model):
__tablename__ = 'hospital'
id = db.Column(db.Integer,
db.Sequence('seq_hospital_id', start=1, increment=1),
primary_key=True)
name = db.Column(db.String(255))
direccion = db.Column(db.String(255))
service = db.Column(db.String(255))
status = db.Column(db.String(1), default=1)
created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('UserModel')
def __init__(self, name, direccion, service, user_id):
self.name = name
self.direccion = direccion
self.service = service
self.user_id = user_id
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
wallet = db.relationship('Wallet', uselist=False)
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 {
'id': self.id,
'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 UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer,
db.Sequence('seq_users_id', start=1, increment=1),
primary_key=True)
identification = db.Column(db.String(255))
email = db.Column(db.String(255))
phone = db.Column(db.String(255))
password = db.Column(db.String(255))
status = db.Column(db.String(1), default=2) # 2 = user new
created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
rol_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
rol = db.relationship('RolModel')
def __init__(self, identification, password, email, phone, rol_id):
self.identification = identification
self.password = password
self.email = email
self.phone = phone
self.rol_id = rol_id
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_identification(cls, identification):
return cls.query.filter_by(identification=identification).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class BrandModel(db.Model):
__tablename__ = 'brands'
brandId = db.Column(db.String(80),primary_key=True,nullable=False,default=DefaultFunc.generateId)
brandName = db.Column(db.String(50),nullable=False)
createDate = db.Column(db.BigInteger,default=time)
updateDate = db.Column(db.BigInteger,onupdate=time)
product = db.relationship('ProductModel',lazy="dynamic")
@classmethod
def fetchAll(cls):
return cls.query.all()
@classmethod
def findById(cls,brandid):
return cls.query.filter_by(brandId=brandid).first()
@classmethod
def findByBrandName(cls,name):
return cls.query.filter_by(brandName=name).first()
def insert(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
password = db.Column(db.String(80))
chatbots = db.relationship("ChatbotModel", lazy="dynamic")
def __init__(self, username: str, password: str):
self.username = username
self.password = password
def json(self) -> UserJSON:
return {"id": self.id, "username": self.username}
@classmethod
def find_by_username(cls, username: str) -> "UserModel":
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id: int) -> "UserModel":
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 ProfileModel(db.Model):
__tablename__ = 'profile'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
lastname = db.Column(db.String(80), nullable=True)
facebook = db.Column(db.String(80), nullable=True)
instragram = db.Column(db.String(80), nullable=True)
location = db.Column(db.Text, nullable=True)
avatar = db.Column(db.Text, nullable=True)
createDate = db.Column(db.BigInteger, default=time)
updateDate = db.Column(db.BigInteger, onupdate=time)
userId = db.Column(db.String(50), db.ForeignKey('users.userId'))
user = db.relationship('UserModel')
@classmethod
def findById(cls, userid):
return cls.query.filter_by(userId=userid).first()
def insert(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Item(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))
stores = db.relationship('Store',
secondary=inventory,
backref=db.backref('items', lazy='dynamic'))
def __init__(self, name, price):
self.name = name
self.price = price
@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 json(self):
return {'name': self.name, 'price': self.price}
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()
@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 Swap(BaseModel):
""" Swap Model class """
__tablename__ = 'swaps'
driver_id = db.Column(db.Integer,
db.ForeignKey('drivers.id'),
nullable=False)
station_id = db.Column(db.Integer,
db.ForeignKey('stations.id'),
nullable=False)
old_battery = db.Column(JSON, nullable=False)
new_battery = db.Column(JSON, nullable=False)
distance_covered = db.Column(db.Float, nullable=False)
energy_used = db.Column(db.Float, nullable=False)
driver = db.relationship('Driver', backref='swap_driver', lazy='joined')
station = db.relationship('Station', backref='swap_station', lazy='joined')
class Suscripcion(db.Model):
idsuscripcion = db.Column(db.Integer, primary_key=True)
tipo = db.Column(db.String(250))
fecha_renovacion = db.Column(db.Date)
fecha_vencimiento = db.Column(db.Date)
estado = db.Column(db.String(50))
relacionuservet = db.relationship('Uservet',
backref='suscripcion',
lazy=True)
relacionpagosuscripcion = db.relationship('PagoSuscripcion',
backref='suscripcion',
lazy=True)
def __init__(self, tipo, fecha_renovacion, fecha_vencimiento, estado):
self.tipo = tipo
self.fecha_renovacion = fecha_renovacion
self.fecha_vencimiento = fecha_vencimiento
self.estado = estado
class OrderHistoryModel(db.Model):
__tablename__ = 'orderhistories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
quantity = db.Column(db.Integer, nullable=False)
flaskSaleStatus = db.Column(db.Boolean, nullable=False)
createDate = db.Column(db.BigInteger, default=time)
updateDate = db.Column(db.BigInteger, onupdate=time)
orderId = db.Column(db.String(80), db.ForeignKey('orders.orderId'))
proId = db.Column(db.String(80), db.ForeignKey('products.proId'))
order = db.relationship('OrderModel')
product = db.relationship('ProductModel')
@classmethod
def fetchAll(cls):
return cls.query.all()
@classmethod
def fetchById(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def fetchByOrderId(cls, orderid):
return cls.query.filter_by(orderId=orderid).all()
@classmethod
def fetchByProId(cls, proid):
return cls.query.filter_by(proId=proid).all()
@classmethod
def insertMany(self, value):
db.session.add_all(value)
db.session.commit()
def insert(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Cliente(db.Model):
idcliente = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(250))
apellidos = db.Column(db.String(250))
dni = db.Column(db.Integer, unique=True)
email = db.Column(db.String(250))
telefono = db.Column(db.String(250))
registradopor = db.Column(db.String(250))
relacionmascota = db.relationship('Mascota', backref='cliente', lazy=True)
relacionatencion = db.relationship('Atencion',
backref='cliente',
lazy=True)
def __init__(self, nombre, apellidos, dni, email, telefono, registradopor):
self.nombre = nombre
self.apellidos = apellidos
self.dni = dni
self.email = email
self.telefono = telefono
self.registradopor = registradopor
class OrderModel(db.Model):
__tablename__ = 'orders'
orderId = db.Column(db.String(80),primary_key=True) #userid + time() +
inOrederStatus = db.Column(db.Boolean,default=True)
createDate = db.Column(db.BigInteger,default=time)
updateDate = db.Column(db.BigInteger,onupdate=time)
userId = db.Column(db.String(50),db.ForeignKey('users.userId'))
user = db.relationship('UserModel')
orderhistory = db.relationship(OrderHistoryModel,lazy="dynamic",cascade="all ,delete-orphan")
@classmethod
def fetchAll(cls):
return cls.query.all()
@classmethod
def generateId(cls,userid):
return f"ORDER_{userid}_{int(time())}"
@classmethod
def fetchJoinAll(cls):
return UserModel.query.filter_by(userId=cls.userId).all()
@classmethod
def findById(cls,orderid):
return cls.query.filter_by(orderId=orderid).first()
@classmethod
def findByUserId(cls,userid):
return cls.query.filter_by(userId=userid).all()
def insert(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Driver(BaseModel):
""" Driver Model class """
__tablename__ = 'drivers'
name = db.Column(db.String(250), nullable=False, unique=True)
license_number = db.Column(db.String(100), nullable=False, unique=True)
motorcycle_id = db.Column(db.Integer,
db.ForeignKey('motorcycles.id'),
nullable=False)
motorcycle = db.relationship('Motorcycle',
backref='driver_motorcycle',
lazy='joined')
class UserModel(db.Model):
__tablename__ = 'users'
userId = db.Column(db.String(50),primary_key=True,default=DefaultFunc.generateId)
password = db.Column(db.String(80),nullable=True)
email = db.Column(db.String(80),nullable=False)
name = db.Column(db.String(50),nullable=True)
role = db.Column(db.SmallInteger,default='0')
createDate = db.Column(db.BigInteger,default=time)
updateDate = db.Column(db.BigInteger,onupdate=time)
profile = db.relationship(ProfileModel,lazy="dynamic",cascade="all ,delete-orphan")
product = db.relationship(ProductModel,lazy="dynamic",cascade="all ,delete-orphan")
order = db.relationship(OrderModel,lazy='subquery',cascade="all ,delete-orphan")
@classmethod
def fetchAll(cls):
return cls.query.all()
@classmethod
def findById(cls,userid) -> "UserModel":
return cls.query.filter_by(userId=userid).first()
@classmethod
def findByEmail(cls,email) -> "UserModel":
return cls.query.filter_by(email=email).first()
@classmethod
def findByName(cls,name) -> "UserModel":
return cls.query.filter_by(name=name).first()
def insert(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class CommentModel(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
commentId = db.Column(db.String(70), primary_key=True) #userid + time()
commentRating = db.Column(db.Integer, default='0')
commentMsg = db.Column(db.Text, nullable=False)
userId = db.Column(db.String(50), db.ForeignKey('users.userId'))
proId = db.Column(db.String(50), db.ForeignKey('products.proId'))
createDate = db.Column(db.BigInteger, default=time)
updateDate = db.Column(db.BigInteger, onupdate=time)
user = db.relationship('UserModel')
product = db.relationship(ProductModel)
@classmethod
def fetchAll(cls):
return cls.query.all()
@classmethod
def fetchByUser(self, userid):
return cls.query.filter_by(userId=userid).all()
@classmethod
def fetchByProduct(self, proid):
return cls.query.filter_by(userId=proid).all()
@classmethod
def insert(self):
db.session.add(self)
db.session.commit()
@classmethod
def delete(self):
db.session.delete(self)
db.session.commit()
class Atencion(db.Model):
idatencion = db.Column(db.Integer, primary_key=True)
# hoy = datetime.now(pytz.timezone('America/Lima'))
fecha_atencion = db.Column(db.DateTime,
default=datetime.now(
pytz.timezone('America/Lima')))
receta = db.Column(db.String(300))
sintomas = db.Column(db.String(300))
informe = db.Column(db.String(300))
observaciones = db.Column(db.String(300))
nombremascota = db.Column(db.String(100))
total = db.Column(db.Float)
idcliente = db.Column(db.Integer, db.ForeignKey('cliente.idcliente'))
idvet = db.Column(db.Integer, db.ForeignKey('vet.idvet'))
atendido_por = db.Column(db.String(100))
creado_por = db.Column(db.String(100))
estado_atencion = db.Column(db.String(100))
nombre_apellido = db.Column(db.String(100))
dni = db.Column(db.String(20))
email = db.Column(db.String(100))
idreservacion = db.Column(db.Integer)
relacionatenciondetalle = db.relationship('AtencionDetalle',
backref='atencion',
lazy=True)
def __init__(self, fecha_atencion, receta, sintomas, informe,
observaciones, nombremascota, total, idcliente, idvet,
atendido_por, creado_por, estado_atencion, nombre_apellido,
dni, email, idreservacion):
self.fecha_atencion = fecha_atencion
self.receta = receta
self.sintomas = sintomas
self.informe = informe
self.observaciones = observaciones
self.nombremascota = nombremascota
self.total = total
self.idcliente = idcliente
self.idvet = idvet
self.atendido_por = atendido_por
self.creado_por = creado_por
self.estado_atencion = estado_atencion
self.nombre_apellido = nombre_apellido
self.dni = dni
self.email = email
self.idreservacion = idreservacion
class Vet(db.Model):
idvet = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(100))
logo = db.Column(db.String(200))
imagen = db.Column(db.String(200))
telefono = db.Column(db.String(100))
whatsapp = db.Column(db.String(100))
acceso = db.Column(db.String(100))
ciudad = db.Column(db.String(100))
distrito = db.Column(db.String(100))
direccion = db.Column(db.String(100))
creado = db.Column(db.DateTime,
default=datetime.now(pytz.timezone('America/Lima')))
vision = db.Column(db.String(500))
mision = db.Column(db.String(500))
mensaje = db.Column(db.String(500))
nombre_unico = db.Column(db.String(30), unique=True)
clave_reporte = db.Column(db.String(200))
uservets = db.relationship('Uservet', backref='vet', lazy=True)
relacionservicios = db.relationship('Servicios', backref='vet', lazy=True)
relacionatencion = db.relationship('Atencion', backref='vet', lazy=True)
relacionempleado = db.relationship('Empleado', backref='vet', lazy=True)
relacionproductos = db.relationship('Productos', backref='vet', lazy=True)
relacionkardex = db.relationship('Kardex', backref='vet', lazy=True)
relacionreservacion = db.relationship('Reservacion',
backref='vet',
lazy=True)
def __init__(self, nombre, logo, imagen, telefono, whatsapp, acceso,
ciudad, distrito, direccion, creado):
self.nombre = nombre
self.logo = logo
self.imagen = imagen
self.telefono = telefono
self.whatsapp = whatsapp
self.acceso = acceso
self.ciudad = ciudad
self.distrito = distrito
self.direccion = direccion
self.creado = creado
class ProductModel(db.Model):
__tablename__ = "products"
proId = db.Column(
db.String(80), nullable=False,
primary_key=True) # PROD_ + serial + pro_name + userId or storeId
proName = db.Column(db.String(50), nullable=False)
proPrice = db.Column(db.Float, nullable=False, default="0")
proImg = db.Column(db.Text, nullable=True, default=None)
proQuantity = db.Column(db.Integer, default='1')
feature = db.Column(db.Text, nullable=True, default=None)
flashSaleStatus = db.Column(db.Boolean, default=False)
# authorId = db.Column(db.String(80),nullable=False)
desc = db.Column(db.Text, nullable=True, default=None)
createDate = db.Column(db.BigInteger, default=time)
updateDate = db.Column(db.BigInteger, onupdate=time)
catId = db.Column(
db.String(80),
db.ForeignKey('catagories.catId'),
nullable=False,
)
userId = db.Column(
db.String(80),
db.ForeignKey('users.userId'),
nullable=True,
)
storeId = db.Column(
db.String(80),
db.ForeignKey('store.storeId'),
nullable=True,
)
brandId = db.Column(
db.String(80),
db.ForeignKey('brands.brandId'),
nullable=True,
default='0',
)
catagory = db.relationship(CatagoryModel)
user = db.relationship('UserModel')
brand = db.relationship('BrandModel')
store = db.relationship(StoreModel)
orderhistory = db.relationship(OrderHistoryModel,
lazy="dynamic",
cascade="all ,delete-orphan")
@classmethod
def newProid(cls, authorid, serialNumber):
return f"PROD_{serialNumber}_{int(time())}_{authorid}"
@classmethod
def findSerial(cls):
return cls.query.count()
@classmethod
def fetchAll(cls):
return cls.query.order_by(cls.createDate.desc()).all()
@classmethod
def findByProId(cls, proid):
return cls.query.filter_by(proId=proid).first()
@classmethod
def isLimit(cls, userid) -> bool:
return cls.query.filter_by(userId=userid).count() > 10
@classmethod
def findByUserId(cls, userid):
return cls.query.filter_by(userId=userid).order_by(
cls.createDate.desc())
@classmethod
def findByStoreId(cls, storeid):
return cls.query.filter_by(storeId=storeid).all()
@classmethod
def insertMany(cls, value):
db.session.add_all(value)
db.session.commit()
def insert(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
