class Uservet(db.Model):
iduservet = 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))
tipo_uservet = db.Column(db.String(250))
estado_uservet = db.Column(db.String(250))
validado = db.Column(db.String(250))
creado = db.Column(db.DateTime,
default=datetime.now(pytz.timezone('America/Lima')))
vet_id = db.Column(db.Integer, db.ForeignKey('vet.idvet'))
idsuscripcion = db.Column(db.Integer,
db.ForeignKey('suscripcion.idsuscripcion'))
idvendedor = db.Column(db.Integer, db.ForeignKey('vendedor.idvendedor'))
def __init__(self, dni, email, password, nombre, apellidos, telefono,
tipo_uservet, estado_uservet, validado, creado, vet_id,
idvendedor):
self.dni = dni
self.email = email
self.password = password
self.nombre = nombre
self.apellidos = apellidos
self.telefono = telefono
self.tipo_uservet = tipo_uservet
self.estado_uservet = estado_uservet
self.validado = validado
self.creado = creado
self.vet_id = vet_id
self.idvendedor = idvendedor
class UserVet(db.Model):
id = db.Column(db.Integer, primary_key = True)
idvet = db.Column(db.Integer,db.ForeignKey('veterinaria.id'))
iduser = db.Column(db.Integer,db.ForeignKey('usuario.id'))
owner = db.Column(db.String(100))
def __init__(self,idvet,iduser,owner):
self.idvet = idvet
self.iduser = iduser
self.owner = owner
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 Empleado(db.Model):
idempleado = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(300))
dni = db.Column(db.String(100))
password = db.Column(db.String(100))
atencion = db.Column(db.String(1))
petshop = db.Column(db.String(1))
reservaciones = db.Column(db.String(1))
servicios = db.Column(db.String(1))
productos = db.Column(db.String(1))
activo = db.Column(db.String(2))
idvet = db.Column(db.Integer, db.ForeignKey('vet.idvet'))
def __init__(self, nombre, dni, password, atencion, petshop, reservaciones,
servicios, productos, activo, idvet):
self.nombre = nombre
self.dni = dni
self.password = password
self.atencion = atencion
self.petshop = petshop
self.reservaciones = reservaciones
self.servicios = servicios
self.productos = productos
self.activo = activo
self.idvet = idvet
class Kardex(db.Model):
idkardex = db.Column(db.Integer, primary_key=True)
fecha_kardex = db.Column(db.DateTime,
default=datetime.now(
pytz.timezone('America/Lima')))
tipo = db.Column(db.String(30))
usuario = db.Column(db.String(50))
producto = db.Column(db.String(50))
cantidad_ingreso = db.Column(db.Integer)
cantidad_salida = db.Column(db.Integer)
idvet = db.Column(db.Integer, db.ForeignKey('vet.idvet'))
idatedet = db.Column(db.Integer, unique=True)
idordendet = db.Column(db.Integer, unique=True)
def __init__(self, fecha_kardex, tipo, usuario, producto, cantidad_ingreso,
cantidad_salida, idvet, idatedet, idordendet):
self.fecha_kardex = fecha_kardex
self.tipo = tipo
self.usuario = usuario
self.producto = producto
self.cantidad_ingreso = cantidad_ingreso
self.cantidad_salida = cantidad_salida
self.idvet = idvet
self.idatedet = idatedet
self.idordendet = idordendet
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 Reservacion(db.Model):
idreservacion = db.Column(db.Integer, primary_key=True)
idvet = db.Column(db.Integer, db.ForeignKey('vet.idvet'))
dni = db.Column(db.String(20))
nombre_apellido = db.Column(db.String(100))
telefono = db.Column(db.String(100))
email = db.Column(db.String(100))
fecha = db.Column(db.Date)
hora_inicio = db.Column(db.String(20))
hora_final = db.Column(db.String(20))
observacion = db.Column(db.String(100))
encargado = db.Column(db.String(100))
estado_reservacion = db.Column(db.String(100))
def __init__(self, idvet, dni, nombre_apellido, telefono, email, fecha,
hora_inicio, hora_final, observacion, encargado,
estado_reservacion):
self.idvet = idvet
self.dni = dni
self.nombre_apellido = nombre_apellido
self.telefono = telefono
self.email = email
self.fecha = fecha
self.hora_inicio = hora_inicio
self.hora_final = hora_final
self.observacion = observacion
self.encargado = encargado
self.estado_reservacion = estado_reservacion
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 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 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 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 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 Wallet(db.Model):
__tablename__ = 'wallets'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False,
unique=True)
amount = db.Column(db.Float, nullable=False, default=0)
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 PagoVendedor(db.Model):
idpagovendedor = db.Column(db.Integer, primary_key=True)
idvendedor = db.Column(db.Integer, db.ForeignKey('vendedor.idvendedor'))
idpagosuscripcion = db.Column(db.String(20))
estado = db.Column(db.String(20))
monto = db.Column(db.String(20))
def __init__(self, idvendedor, idpagosuscripcion, estado, monto):
self.idvendedor = idvendedor
self.idpagosuscripcion = idpagosuscripcion
self.estado = estado
self.monto = monto
class Services(db.Model):
id = db.Column(db.Integer,primary_key = True)
idvet = db.Column(db.Integer,db.ForeignKey('veterinaria.id'))
tipo = db.Column(db.String(200))
nombre = db.Column(db.String(200))
precio = db.Column(db.Float)
foto = db.Column(db.String(250))
def __init__(self,idvet,tipo,nombre,precio,foto):
self.idvet = idvet
self.tipo = tipo
self.nombre = nombre
self.precio = precio
self.foto = foto
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 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 Servicios(db.Model):
idServicio = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(250))
tipo = db.Column(db.String(250))
precio = db.Column(db.Float)
detalles = db.Column(db.String(250))
idvet = db.Column(db.Integer, db.ForeignKey('vet.idvet'))
def __init__(self, nombre, tipo, precio, detalles, idvet):
self.nombre = nombre
self.tipo = tipo
self.precio = precio
self.detalles = detalles
self.idvet = idvet
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 Productos(db.Model):
idProducto = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(250))
descripcion = db.Column(db.String(250))
precio = db.Column(db.Float)
stock = db.Column(db.Integer)
idvet = db.Column(db.Integer, db.ForeignKey('vet.idvet'))
__table_args__ = (db.UniqueConstraint('nombre', 'idvet'), )
def __init__(self, nombre, descripcion, precio, stock, idvet):
self.nombre = nombre
self.descripcion = descripcion
self.precio = precio
self.stock = stock
self.idvet = idvet
class Pet(db.Model):
id = db.Column(db.Integer,primary_key=True)
name = db.Column(db.String(255))
birthdate = db.Column(db.DateTime)
color = db.Column(db.String(25))
bread = db.Column(db.String(55))
photo = db.Column(db.String(255))
owner = db.Column(db.Integer,db.ForeignKey('usuario.id'))
def __init__(self,name,birthdate,color,bread,photo,owner):
self.name= name
self.birthdate= birthdate
self.color= color
self.bread= bread
self.photo= photo
self.owner= owner
class Mensaje(db.Model):
idmensaje = db.Column(db.Integer, primary_key=True)
iduservet = db.Column(db.Integer, db.ForeignKey('uservet.iduservet'))
nombre = db.Column(db.String(20))
mensaje = db.Column(db.String(200))
tipo = db.Column(db.String(1))
creado = db.Column(db.DateTime,
default=datetime.now(pytz.timezone('America/Lima')))
def __init__(self, iduservet, nombre, mensaje, tipo, creado):
self.iduservet = iduservet
self.nombre = nombre
self.mensaje = mensaje
self.tipo = tipo
self.creado = creado
class AtencionDetalle(db.Model):
idatenciondetalle = db.Column(db.Integer, primary_key=True)
tipo = db.Column(db.String(100))
nombre = db.Column(db.String(250))
cantidad = db.Column(db.Integer)
precio_unitario = db.Column(db.Float)
subtotal = db.Column(db.Float)
idatencion = db.Column(db.Integer, db.ForeignKey('atencion.idatencion'))
def __init__(self, tipo, nombre, cantidad, precio_unitario, subtotal,
idatencion):
self.tipo = tipo
self.nombre = nombre
self.cantidad = cantidad
self.precio_unitario = precio_unitario
self.subtotal = subtotal
self.idatencion = idatencion
class Mascota(db.Model):
idmascota = db.Column(db.Integer, primary_key=True)
idcliente = db.Column(db.Integer, db.ForeignKey('cliente.idcliente'))
nombre = db.Column(db.String(250))
tipo = db.Column(db.String(250))
raza = db.Column(db.String(250))
nacimiento = db.Column(db.Date)
peso = db.Column(db.String(250))
observaciones = db.Column(db.String(1000))
def __init__(self, idcliente, nombre, tipo, raza, nacimiento, peso,
observaciones):
self.idcliente = idcliente
self.nombre = nombre
self.tipo = tipo
self.raza = raza
self.nacimiento = nacimiento
self.peso = peso
self.observaciones = observaciones
class Order(db.Model):
# 数据库的表名
__tablename__ = 'py_order'
# 单个属性 对应数据库中的列 db.BigInteger 为列的类型此列为bigint,primary_key为主键
orderId = db.Column(db.BigInteger, primary_key=True)
# 状态
status = db.Column(db.Integer, unique=False)
# 用户 openid
openid = db.Column(db.String(255), unique=False)
# money 金额
money = db.Column(db.String(255), unique=False)
# time 创建时间
createTime = db.Column(db.DateTime, unique=False, default=db.Datetime.now)
# 产品Id
contentId = db.Column(db.BigInteger, db.ForeignKey('py_content.contentId'))
class ContentImg(db.Model):
# 数据库的表名
__tablename__ = 'py_content'
# 单个属性 对应数据库中的列 db.BigInteger 为列的类型此列为bigint,primary_key为主键
contentId = db.Column(db.BigInteger, primary_key=True)
# 标题
contentTitle = db.Column(db.String(255), unique=False)
# 浏览量
contentBrowse = db.Column(db.Integer, unique=False)
# 下载量
contentDownload = db.Column(db.Integer, unique=False)
# 壁纸
contentImg = db.Column(db.String(255), unique=False)
# 外键
forgetId = db.Column(db.BigInteger, db.ForeignKey('py_class.classId'))
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 PagoSuscripcion(db.Model):
idpagosuscripcion = db.Column(db.Integer, primary_key=True)
idsuscripcion = db.Column(db.Integer,
db.ForeignKey('suscripcion.idsuscripcion'))
monto = db.Column(db.String(20))
estado = db.Column(db.String(20))
imagen = db.Column(db.String(100))
creado = db.Column(db.DateTime,
default=datetime.now(pytz.timezone('America/Lima')))
observacion = db.Column(db.String(200))
mes = db.Column(db.String(20))
anio = db.Column(db.String(20))
def __init__(self, idsuscripcion, monto, estado, imagen, creado,
observacion, mes, anio):
self.idsuscripcion = idsuscripcion
self.monto = monto
self.estado = estado
self.imagen = imagen
self.creado = creado
self.observacion = observacion
self.mes = mes
self.anio = anio
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()
