class searchAdClientOrderBill(db.Model, BaseModelMixin, CommentMixin):
__tablename__ = 'searchad_bra_client_order_bill'
id = db.Column(db.Integer, primary_key=True)
company = db.Column(db.String(100))
client_id = db.Column(db.Integer, db.ForeignKey('searchAd_client.id'))
client = db.relationship('searchAdClient', backref=db.backref('searchad_bra_client_bill', lazy='dynamic'))
medium_id = db.Column(db.Integer, db.ForeignKey('searchAd_medium.id'))
medium = db.relationship('searchAdMedium', backref=db.backref('searchad_bra_medium_bill', lazy='dynamic'))
resource_type = db.Column(db.Integer) # 推广形式
money = db.Column(db.Float(), default=0.0)
rebate_money = db.Column(db.Float(), default=0.0)
start = db.Column(db.Date)
end = db.Column(db.Date)
def __init__(self, company, client, medium, resource_type, money, rebate_money, start=None, end=None):
self.company = company
self.client = client
self.medium = medium
self.resource_type = resource_type
self.money = money or 0.0
self.rebate_money = rebate_money or 0.0
self.start = start or datetime.date.today()
self.end = end or datetime.date.today()
@property
def resource_type_cn(self):
return BILL_RESOURCE_TYPE_CN.get(self.resource_type)
class Commission(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref('commission_user',
lazy='dynamic'),
foreign_keys=[user_id])
year = db.Column(db.Integer)
rate = db.Column(db.Float)
creator_id = db.Column(db.Integer, db.ForeignKey('user.id'))
creator = db.relationship('User',
backref=db.backref('commission_creator',
lazy='dynamic'),
foreign_keys=[creator_id])
create_time = db.Column(db.DateTime)
__table_args__ = (db.UniqueConstraint('user_id',
'year',
name='_commission_user_year'), )
__mapper_args__ = {'order_by': year.desc()}
def __init__(self,
user,
year=None,
rate=None,
creator=None,
create_time=None):
self.user = user
self.creator = creator
self.year = year or datetime.datetime.now().year
self.rate = rate or 0.0
self.create_time = datetime.date.today()
class Record(Entry, db.Model):
def __init__(self, user_id) -> None:
super().__init__()
self.user_id = user_id
__tablename__ = 'glycaemia_record'
user_id = db.Column(db.Integer,
db.ForeignKey('{}.id'.format(User.__tablename__)),
nullable=False)
state_id = db.Column(db.Integer,
db.ForeignKey('{}.id'.format(State.__tablename__)),
nullable=False)
state = db.relationship(State, backref="states")
foods = db.relationship('Food', backref='record', lazy=True)
value = db.Column(db.Integer, nullable=False)
comment = db.Column(db.String(250), nullable=True)
@classmethod
def findByUserEmail(cls, email):
return cls.query.join(User).filter(User.email == email).all()
@classmethod
def findByUserId(cls, user_id):
return cls.query.filter_by(user_id=user_id).order_by(
desc(Record.takenAt)).all()
@classmethod
def getById(cls, id):
return cls.query.filter_by(id=id).first()
@classmethod
def deleteById(cls, id):
return cls.query.filter_by(id=id).delete()
class User(db.Model):
__tablename__ = 'users'
email = db.Column(db.String, primary_key=True)
google_id = db.Column(db.String)
first_name = db.Column(db.String)
last_name = db.Column(db.String)
user_secret = db.Column(db.String)
profile_picture_url = db.Column(db.String)
contacts = db.relationship('UserContact')
location_history = db.relationship('UserLocation',
order_by='desc(UserLocation.time)')
tracking_info = db.relationship('TrackingInfo', uselist=False)
def __init__(self, gid, email, first, last, picture, secret):
self.google_id = gid
self.email = email
self.first_name = first
self.last_name = last
self.profile_picture_url = picture
self.user_secret = secret
def __repr__(self):
return 'First: {0} Last: {1} Email: {2}'.format(
self.first_name, self.last_name, self.email)
def marshal(self):
return marshal(self, user_fields)
@staticmethod
def exists(email):
user = db.session.query(User).filter(User.email == email).one_or_none()
if user is None:
return False, None
else:
return True, user
@staticmethod
def with_token(token):
user = db.session.query(User).filter(
User.user_secret == token).one_or_none()
if user is None:
return False, None
else:
return True, user
@staticmethod
def with_email(email):
exists, user = User.exists(email)
if exists == False:
raise Exception('No user found')
return user
@staticmethod
def with_gid(gid):
user = db.session.query(User).filter(
User.google_id == gid).one_or_none()
return user
class TransactionModel(db.Model):
__tablename__ = 'transaction'
transaction_id = db.Column(db.BigInteger,
primary_key=True,
autoincrement=True)
amount = db.Column(db.Float, nullable=False)
created_at = db.Column(db.TIMESTAMP,
server_default=db.func.current_timestamp())
author_account = db.Column(db.String(34),
db.ForeignKey('account.account_number',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
receiver_account = db.Column(db.String(34),
db.ForeignKey('account.account_number',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
author = db.relationship('AccountModel', foreign_keys=author_account)
receiver = db.relationship('AccountModel', foreign_keys=receiver_account)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class UserCourseModel(db.Model):
__tablename__ = 'user_course'
user_course_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
course_id = db.Column(db.Integer,
db.ForeignKey('course.course_id',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
course = db.relationship('CourseModel', foreign_keys=course_id)
user = db.relationship('UserModel', foreign_keys=user_id)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class File(db.Model, Deletable):
__tablename__ = "files"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
uploaded_name = db.Column(db.String(255), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
folder_id = db.Column(db.Integer,
db.ForeignKey("folders.id"),
nullable=False)
user = db.relationship("User", foreign_keys=user_id)
folder = db.relationship(
"Folder",
foreign_keys=folder_id,
uselist=False,
lazy="select",
back_populates="files",
)
def __init__(self, user_id, name: str, folder_id: int) -> None:
extension = name.split(".")[-1]
self.user_id = user_id
self.name = name
self.uploaded_name = (str(user_id) + "-" + str(uuid4().hex) + "." +
extension)
self.folder_id = folder_id
def serialize(self) -> dict:
return {"id": self.id, "name": self.name}
class CardModel(db.Model):
__tablename__ = 'card'
card_number = db.Column(db.String(17), primary_key=True)
amount = db.Column(db.Float, nullable=False)
active_to = db.Column(db.DATE, nullable=False)
cvv = db.Column(db.SmallInteger, nullable=False)
created_at = db.Column(db.TIMESTAMP,
server_default=db.func.current_timestamp())
owner_id = db.Column(db.Integer,
db.ForeignKey('user.user_id',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
account_number = db.Column(db.String(34),
db.ForeignKey('account.account_number',
onupdate='cascade',
ondelete='restrict'),
nullable=False)
owner = db.relationship('UserModel', foreign_keys=owner_id)
account = db.relationship('AccountModel', foreign_keys=account_number)
def save_to_db(self):
db.session.add(self)
db.session.commit()
class VenueGenre(db.Model):
__tablename__ = 'venue_genre'
genre_id = db.Column(db.Integer,
db.ForeignKey('genres.id'),
primary_key=True)
venue_id = db.Column(db.Integer,
db.ForeignKey('venues.id'),
primary_key=True)
genre = db.relationship('Genre',
backref=db.backref('venue_genre',
cascade='all, delete-orphan'))
venue = db.relationship('Venue',
backref=db.backref('venue_genre',
cascade='all, delete-orphan'))
__table_args__ = (db.UniqueConstraint(genre_id, venue_id), )
@classmethod
def delete_old(cls, venue_id, genres):
venues_to_delete = db.session.query(cls).filter_by(
venue_id=venue_id).filter(cls.genre_id.notin_(genres))
venues_to_delete.delete(synchronize_session=False)
@classmethod
def get_genres_ids(cls, venue_id):
results = cls.query.filter_by(venue_id=venue_id).all()
return [str(result.genre_id) for result in results]
def __repr__(self):
return f'<VenreGenre venue {self.venue_id} genre {self.genre_id}>'
class PerformanceUser(db.Model, BaseModelMixin):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref('performance_user',
lazy='dynamic'))
performance = db.relationship('Performance',
backref=db.backref('performance_user_money',
lazy='dynamic'))
performance_id = db.Column(db.Integer, db.ForeignKey('performance.id'))
year = db.Column(db.Integer)
q_month = db.Column(db.String(10))
money = db.Column(db.Float) # 销售目标
create_time = db.Column(db.DateTime)
__mapper_args__ = {'order_by': create_time.desc()}
def __init__(self, user, year, q_month, money, create_time, performance):
self.user = user
self.year = year
self.performance = performance
self.q_month = q_month
self.money = money
self.create_time = create_time or datetime.date.today()
@property
def status(self):
return self.performance.status
class searchAdConfirmMoney(db.Model, BaseModelMixin):
__tablename__ = 'searchad_bra_client_order_confirm_money'
id = db.Column(db.Integer, primary_key=True)
client_order_id = db.Column(
db.Integer, db.ForeignKey('searchAd_bra_client_order.id')) # 客户合同
client_order = db.relationship(
'searchAdClientOrder', backref=db.backref('searchad_confirm_client_order', lazy='dynamic'))
order_id = db.Column(
db.Integer, db.ForeignKey('searchAd_bra_order.id')) # 客户合同
order = db.relationship(
'searchAdOrder', backref=db.backref('searchad_confirm_order', lazy='dynamic'))
money = db.Column(db.Float())
rebate = db.Column(db.Float())
year = db.Column(db.Integer)
Q = db.Column(db.String(2))
create_time = db.Column(db.DateTime)
__mapper_args__ = {'order_by': year.desc()}
def __init__(self, client_order, year, Q, order, money=0.0, rebate=0.0, create_time=None):
self.client_order = client_order
self.order = order
self.money = money
self.rebate = rebate
self.year = year
self.Q = Q
self.create_time = create_time or datetime.date.today()
@property
def time(self):
return str(self.year) + str(self.Q)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
caption = db.Column(db.String(80), nullable=False)
foto = db.Column(db.String(120), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
users = db.relationship('User', backref='user')
userlikes = db.relationship('User',
secondary=likes,
backref=db.backref('likes', lazy='dynamic'))
# UserComment = db.relationship('User', secondary=Comments,
# backref=db.backref('Comment', lazy='dynamic'))
UserComment = db.relationship('Comment')
created_date = db.Column(db.DateTime, default=datetime.now, nullable=True)
def __repr__(self):
return '<Post %r %r>' % (self.id, self.caption)
def data(self, a):
return {
"id": self.id,
"caption": self.caption,
"foto": self.foto,
"users": self.users.username,
"totallike": len(self.userlikes),
"userlikes": checkdata(a, self.userlikes)
}
class Show(db.Model):
""" Show Model """
__tablename__ = 'shows'
id = db.Column(db.Integer, primary_key=True)
artist_id = db.Column(db.Integer,
db.ForeignKey('artists.id'),
nullable=False)
venue_id = db.Column(db.Integer,
db.ForeignKey('venues.id'),
nullable=False)
start_time = db.Column(db.DateTime, nullable=False)
venue = db.relationship('Venue')
artist = db.relationship('Artist')
def show_artist(self):
""" Returns a dictinary of artists for the show """
return {
'artist_id': self.artist_id,
'artist_name': self.artist.name,
'artist_image_link': self.artist.image_link,
# convert datetime to string
'start_time': self.start_time.strftime('%Y-%m-%d %H:%M:%S')
}
def show_venue(self):
""" Returns a dictinary of venues for the show """
return {
'venue_id': self.venue_id,
'venue_name': self.venue.name,
'venue_image_link': self.venue.image_link,
# convert datetime to string
'start_time': self.start_time.strftime('%Y-%m-%d %H:%M:%S')
}
class UserPromoModel(db.Model):
__tablename__ = "userpromo"
userpromo_id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
promo_code = db.Column(db.String(8), db.ForeignKey('promocode.promo_code'))
userpromo_validity = db.Column(db.Date, nullable=False)
userpromo_used = db.Column(db.Boolean, default=False, nullable=False)
user = db.relationship('UsersModel')
promo = db.relationship('PromoCodeModel')
def __init__(self, user_id, promo_code, userpromo_validity,
userpromo_used):
self.user_id = user_id
self.promo_code = promo_code
self.userpromo_used = userpromo_used
self.userpromo_validity = userpromo_validity
def json(self):
return {
'userpromo_id': self.userpromo_id,
'promo_code': self.promo_code,
'user_id': self.user_id,
'userpromo_used': self.userpromo_used,
'userpromo_validity': str(self.userpromo_validity)
}
@classmethod
def find_by_id(cls, userpromo_id):
return cls.query.filter_by(userpromo_id=userpromo_id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class Message(db.Model):
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(128))
sender_id = db.Column(db.Integer, db.ForeignKey('messages_component.id'))
sender = db.relationship('MessagesComponent',
backref='sent_messages',
foreign_keys=[sender_id])
recipients = db.relationship('MessagesComponent',
backref=db.backref('messages',
lazy='dynamic'),
secondary=recipients_table)
def __init__(self, content='', sender=None, recipients=None):
self.content = content
self.sender = sender
self.recipients = recipients or []
@property
def sender_name(self):
return getattr(self.sender, 'name', "DM")
def __serialize__(self):
return {
'id': self.id,
'content': self.content,
'sender': self.sender_id,
'recipients': [recipient.id for recipient in self.recipients]
}
class Role(db.Model):
'''
鉴权
'''
__tablename__ = 'db_role'
id = db.Column(db.Integer, nullable=False, primary_key=True, index=True, autoincrement=True)
role_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
name = db.Column(db.String(64), nullable=False, unique=True)
mark = db.Column(db.String(64), nullable=False, unique=True)
disable = db.Column(db.Boolean, index=True, default=False)
admins = db.relationship('Admin', backref='role')
interfaces = db.relationship('Interface',
secondary=InterfaceToRole,
backref=db.backref('roles', lazy='dynamic'),
lazy='dynamic')
menus = db.relationship('Menu',
secondary=MenuToRole,
backref=db.backref('roles', lazy='dynamic'),
lazy='dynamic')
__table_args__ = (table_args())
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "role_list" in dict:
del dict["role_list"]
return dict
def __repr__(self):
return '<Role %r>' % self.name
class UserGrades(db.Model):
__tablename__ = 'user_grades'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
user = db.relationship("User", backref=db.backref('grades', order_by=id))
assignment_id = db.Column(db.Integer(), db.ForeignKey('assignment.id'))
assignment = db.relationship("Assignment",
backref=db.backref('grades', order_by=id))
score = db.Column(db.Numeric())
class Poetry(db.Model):
__tablename__ = 'poetry'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(200), nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
content_path = db.Column(db.Text)
poet_id = db.Column(db.Integer, db.ForeignKey('poeter.id'))
poet = db.relationship('Poeter', backref=db.backref('poetries'))
categories = db.relationship('PoetryCategory', secondary=poetry_tag, backref=db.backref('poetries'))
class Note(db.Model):
__tablename__ = 'note'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(300), nullable=False)
create_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
content_path = db.Column(db.Text)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('notes'))
cat_id = db.Column(db.Integer, db.ForeignKey('note_category.id'))
category = db.relationship('NoteCategory', backref=db.backref('notes'))
class Pedido(db.Model):
__tablename__ = 'pedidos'
id = db.Column(db.Integer, primary_key=True)
creation_date = db.Column(db.TIMESTAMP, server_default=db.func.current_timestamp(), nullable=False)
cliente_id = db.Column(db.Integer, db.ForeignKey('clientes.id', ondelete='CASCADE'), nullable=False)
cliente = db.relationship('Cliente', backref=db.backref('clientes', lazy='dynamic'))
itens_pedido = db.relationship('ItensPedido', lazy='select', backref=db.backref('itens_pedidos', lazy='joined'))
def __init__(self, cliente_id):
self.cliente_id = cliente_id
class Deadlines(db.Model):
__tablename__ = 'deadlines'
id = db.Column(db.Integer(), primary_key=True)
assignment_id = db.Column(db.Integer(), db.ForeignKey('assignment.id'))
assignment = db.relationship("Assignment",
backref=db.backref('deadlines', order_by=id))
section_id = db.Column(db.Integer(), db.ForeignKey('section.id'))
section = db.relationship("Section",
backref=db.backref('deadlines', order_by=id))
deadline = db.Column(db.DateTime())
acid = db.Column(db.String(255))
class Model(db.Model):
id = db.Column(db.Integer, primary_key=True)
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'))
name = db.Column(db.String(256), index=True)
generation = db.relationship('Generation', backref='model', lazy='dynamic')
series = db.relationship('Series', backref='model', lazy='dynamic')
modifications = db.relationship('Modifications', backref='model', lazy='dynamic')
def __repr__(self):
return '<Model {}>'.format(self.name)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), nullable=False)
password = db.Column(db.String(120), nullable=False)
posts = db.relationship('Post', backref='post')
prodlikes = db.relationship('Post',
secondary=likes,
backref=db.backref('likes', lazy='dynamic'))
UserComment = db.relationship('Comment')
# comment=db.relationship('Comment',backref='Comment')
def __repr__(self):
return '<User %r %r>' % (self.id, self.username)
class AdministratorUserRole(db.Model):
"""
用户角色中间表
"""
__tablename__ = 'admin_user_role'
id = db.Column('id', db.Integer, primary_key=True, doc='用户角色ID')
user_id = db.Column(db.Integer, db.ForeignKey('admin_user.id'), doc='管理员ID')
user = db.relationship("Administrator", uselist=False)
role_id = db.Column(db.Integer, db.ForeignKey('admin_role.id'), doc='管理员ID')
role = db.relationship("AdministratorRole", uselist=False)
status = db.Column(db.Integer, default=1, doc='状态')
ctime = db.Column('create_time', db.DateTime, default=datetime.now, doc='创建时间')
utime = db.Column('update_time', db.DateTime, default=datetime.now, onupdate=datetime.now, doc='更新时间')
class College(db.Model):
"""
Model class for College entity
Relationship: One to many relationship with Department.
"""
id = db.Column(db.Integer, nullable=False, primary_key=True)
name = db.Column(db.String(400))
description = db.Column(db.String(5000))
short_name = db.Column(db.String(50))
url = db.Column(db.String(1000))
department = db.relationship('Department', backref='department_owner', lazy='dynamic')
general_course = db.relationship('General', backref='general_course_owner', lazy='dynamic')
class Invitation(db.Model):
__tablename__ = "invitation"
i_code = db.Column(db.String(64), primary_key=True)
inviter_uid = db.Column(db.Integer, db.ForeignKey("user.uid"))
privilege_id = db.Column(db.Integer, db.ForeignKey("privilege.pid"))
inviter = db.relationship("User",
backref="invitation_codes",
foreign_keys="Invitation.inviter_uid")
privilege = db.relationship("Privilege",
backref="invitation_codes",
foreign_keys="Invitation.privilege_id")
def __repr__(self):
return '<Invitation %r>' % self.i_code
class RolePermission(db.Model):
__tablename__ = 'role_permissions'
role_id = db.Column(db.BigInteger,
db.ForeignKey('roles.id'),
primary_key=True)
permission_id = db.Column(db.BigInteger,
db.ForeignKey('permissions.id'),
primary_key=True)
role = db.relationship('Role',
backref=db.backref('role_permissions',
cascade='all, delete-orphan',
lazy='joined'))
permission = db.relationship(Permission, lazy='joined')
class Location(db.Model):
__tablename__ = 'country'
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.Unicode)
code = db.Column(db.Unicode)
devices = db.relationship('Location', backref='country', lazy='select')
class Folder(db.Model):
'''
文件夹
'''
__tablename__ = 'db_folder'
id = db.Column(db.Integer, nullable=False, primary_key=True, index=True, autoincrement=True)
folder_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
admin_id = db.Column(db.String(36), index=True, default=None)
pid = db.Column(db.String(36), nullable=False, index=True, default='0')
name = db.Column(db.String(36), index=True, nullable=False)
is_sys = db.Column(db.Boolean, index=True, default=True) # True = 系统文件夹
create_time = db.Column(db.DateTime, index=True, default=datetime.datetime.now)
documents = db.relationship('Document', backref='folder')
__table_args__ = (table_args())
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "create_time" in dict:
dict["create_time"] = dict["create_time"].strftime('%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<Folder %r>' % self.name
class Menu(db.Model):
'''
菜单
'''
__tablename__ = 'db_menu'
id = db.Column(db.Integer, nullable=False, primary_key=True, index=True, autoincrement=True)
menu_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
pid = db.Column(db.String(36), nullable=False, index=True, default='0')
name = db.Column(db.String(64), index=True, nullable=False, unique=True)
title = db.Column(db.String(64), nullable=False, unique=True)
path = db.Column(db.String(255), nullable=False, unique=True)
icon = db.Column(db.String(255), nullable=False)
mark = db.Column(db.String(255), nullable=False, unique=True)
component = db.Column(db.String(255), nullable=False)
componentPath = db.Column(db.String(255), nullable=False)
cache = db.Column(db.Boolean, index=True, default=True)
sort = db.Column(db.SmallInteger, index=True, default=1)
disable = db.Column(db.Boolean, index=True, default=False)
interfaces = db.relationship('Interface',
secondary=InterfaceToMenu,
backref=db.backref('menus', lazy='dynamic'),
lazy='dynamic')
__table_args__ = (table_args())
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
return dict
def __repr__(self):
return '<Menu %r>' % self.title
