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)
is_disabled = db.Column(db.Boolean, index=True, default=False)
role_list = db.Column(db.Text)
admins = db.relationship('Admin', backref='role')
__table_args__ = {'useexisting': True, 'mysql_engine': 'InnoDB'}
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 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 Transactions(db.Model):
id = db.Column(db.Integer, primary_key=True)
payment_method_id = db.Column(db.Integer,
db.ForeignKey('payment_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
shipment_method_id = db.Column(db.Integer,
db.ForeignKey('shipment_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
insurance_method_id = db.Column(db.Integer,
db.ForeignKey('insurance_method.id',
ondelete='CASCADE'),
nullable=False,
default=1)
shipment_price = db.Column(db.Float, default=100)
insurance_price = db.Column(db.Float, default=0)
total = db.Column(db.Float)
payment_status = db.Column(db.Integer, nullable=True)
receiver_name = db.Column(db.String(50))
receiver_phone = db.Column(db.String(14))
receiver_address = db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
updated_at = db.Column(db.DateTime, default=db.func.current_timestamp())
def __repr__(self):
return "<Transactions %r>" % self.id
class Generation(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(256), index=True)
model_id = db.Column(db.Integer, db.ForeignKey('model.id'))
year_begin = db.Column(db.String(128), index=True)
year_end = db.Column(db.String(128), index=True)
series = db.relationship('Series', backref='generation', lazy='dynamic')
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 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 User(db.Model):
__tablename__ = 'users'
no = db.Column(db.Integer, primary_key=True, autoincrement=True)
id = db.Column(db.String(30), nullable=False, unique=True)
pw = db.Column(db.String(64), nullable=False)
name = db.Column(db.String(20), nullable=False)
passthru = db.Column(db.Boolean, nullable=False, default=True)
def check_password(self, pw):
h = hashlib.sha256()
h.update(pw.encode('utf-8'))
return (self.pw == h.hexdigest())
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return self.no
class Product(BaseModel):
__tablename__ = "products"
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
autoincrement=True)
company = db.Column(db.String(50), nullable=True)
category = db.Column(db.String(50), nullable=True)
subcategory = db.Column(db.String(50), nullable=True)
product_name = db.Column(db.String(255), nullable=False)
price = db.Column(db.String(50), nullable=True)
image_link = db.Column(db.String(255), nullable=True)
product_url = db.Column(db.String(255), nullable=True)
description = db.Column(db.Text, nullable=True)
name = db.Column(db.String(50), nullable=True)
email = db.Column(db.String(50), nullable=True)
phone_number = db.Column(db.String(50), nullable=True)
def __init__(self, company, category, subcategory, product_name, price,
image_link, product_url, description):
self.company = company
self.category = category
self.subcategory = subcategory
self.product_name = product_name
self.price = price
self.image_link = image_link
self.product_url = product_url
self.description = description
def set_owner(self, name, email, phone_number):
self.name = name
self.email = email
self.phone_number = phone_number
class Update_change(Node_Base):
__tablename__ = 'update_change'
id = Column(db.Integer,primary_key=True, autoincrement=True)
update_id=Column(db.String(255), db.ForeignKey('updates.update_id'))
change_id= Column(db.String(255), db.ForeignKey('changes.change_id'))
def __repr__(self):
return "<Update_change(update_id='%s',change_id='%s')>" %(self.update_id,self.change_id)
class LoginLock(db.Model):
'''
登录锁定
'''
__tablename__ = 'db_login_lock'
id = db.Column(db.Integer,
nullable=False,
primary_key=True,
index=True,
autoincrement=True)
lock_id = db.Column(db.String(36), index=True, nullable=False, unique=True)
user_id = db.Column(db.String(36), index=True, nullable=False)
flag = db.Column(db.Boolean, index=True, default=False) # 是否锁定
number = db.Column(db.Integer, primary_key=True, default=0)
ip = db.Column(db.String(36), index=True)
lock_time = db.Column(db.DateTime)
__table_args__ = {'useexisting': True, 'mysql_engine': 'InnoDB'}
def to_json(self):
dict = self.__dict__
if "_sa_instance_state" in dict:
del dict["_sa_instance_state"]
if "lock_time" in dict:
dict["lock_time"] = dict["lock_time"].strftime('%Y-%m-%d %H:%M:%S')
return dict
def __repr__(self):
return '<LoginLock %r>' % self.lock_id
class Log(db.Model):
'''
日志
'''
__tablename__ = 'db_log'
id = db.Column(db.Integer, nullable=False, primary_key=True, index=True, autoincrement=True)
username = db.Column(db.String(64), index=True, nullable=False)
content = db.Column(db.Text) # 错误内容
path = db.Column(db.Text, nullable=False)
method = db.Column(db.String(36), nullable=False)
params = db.Column(db.Text) # 请求参数
ip = db.Column(db.String(255))
time = db.Column(db.Integer, nullable=False)
status = db.Column(db.SmallInteger, nullable=False, index=True, default=1) # 0 成功 1 失败 2 禁用
type = db.Column(db.SmallInteger, nullable=False, index=True, default=1) # 0 其他 1 登录
create_time = db.Column(db.DateTime, index=True, default=datetime.datetime.now)
__table_args__ = {
'useexisting': True,
'mysql_engine': 'InnoDB'
}
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 '<Log %r>' % self.id
class AdminModel(db.Model):
__tablename__ = 'admin'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(20), nullable=False)
priviledges = db.Column(db.String(3), nullable=False)
fcmtoken = db.Column(db.String(300), nullable=False)
def json(self):
return {
'id': self.id,
'username': self.username,
'priviledges': self.priviledges
}
@classmethod
def find_by_username(cls, email):
return cls.query.filter_by(username=email).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.String, primary_key=True)
name = db.Column(db.String(120))
email = db.Column(db.String(120))
phone_number = db.Column(db.String(120))
def __init__(self, name, email, phone_number):
self.id = str(uuid.uuid4())
self.name = name
self.email = email
self.phone_number = phone_number
@staticmethod
def create_user(user):
db.session.add(user)
db.session.commit()
@staticmethod
def get_user_by_email(email):
user = User.query.filter_by(email=email).first()
user_dict = user.__dict__
user_dict.pop('_sa_instance_state')
return user_dict
class Read(Resource, db.Model):
def __init__(self, user_id) -> None:
super().__init__()
self.user_id = user_id
__tablename__ = 'user_keys_read'
user_id = db.Column(db.Integer, db.ForeignKey('{}.id'.format(User.__tablename__)), nullable=False)
username = db.Column(db.String(100), nullable=False, unique=False)
value = db.Column(db.String(64), nullable=False, unique=True)
@classmethod
def findByUserEmail(cls, email):
return cls.query.join(User).filter(User.email == email).order_by(desc(Read.createdAt)).all()
@classmethod
def getByUsername(cls, username):
return cls.query.filter(Read.username == username).first()
@classmethod
def generateKey(cls):
length = 8
key = ''
for i in range(length): key += (str(chr(random.randint(97, 122))))
return key.upper()
@classmethod
def deleteById(cls, id):
return cls.query.filter_by(id=id).delete()
class Action(db.Model):
__tablename__ = 'actions'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String())
cost = db.Column(db.Boolean)
turn = db.Column(db.Boolean)
description = db.Column(db.String())
all = db.Column(db.Boolean)
current = db.Column(db.Boolean)
any = db.Column(db.Boolean)
var = db.Column(db.Boolean)
none = db.Column(db.Boolean)
hide = db.Column(db.Boolean)
def format(self):
return {
'id': self.id,
'name': self.name,
'cost': self.cost,
'turn': self.turn,
'description': self.description,
'all': self.all,
'current': self.current,
'any': self.any,
'var': self.var,
'none': self.none,
'hide': self.hide
}
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 SkillTable(db.Model):
__tablename__ = 'skill_tables'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
skill_id = db.Column(db.Integer, db.ForeignKey('skills.id'))
dc = db.Column(db.Integer)
description = db.Column(db.String())
check_id = db.Column(db.Integer, db.ForeignKey('checks.id'))
modifier_id = db.Column(db.Integer, db.ForeignKey('modifiers.id'))
degree = db.Column(db.Boolean)
measurement = db.Column(db.Integer)
complexity = db.Column(db.String())
modifier = db.Column(db.Boolean)
circumstance = db.Column(db.Boolean)
requires_sub = db.Column(db.Boolean)
def format(self):
return {
'id': self.id,
'skill_id': self.skill_id,
'dc': self.dc,
'description': self.description,
'check_id': self.check_id,
'modifier_id': self.modifier_id,
'degree': self.degree,
'measurement': self.measurement,
'complexity': self.complexity,
'modifier': self.modifier,
'circumstance': self.circumstance,
'requires_sub': self.requires_sub
}
class Session(db.Model):
uuid = db.Column(db.String(36), primary_key=True)
user_uuid = db.Column(db.String(36))
def __init__(self, uuid, user_uuid=None):
self.uuid = uuid
self.user_uuid = user_uuid
class EquipOpposed(db.Model):
__tablename__ = 'equipment_opposed'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
equip_id = db.Column(db.Integer, db.ForeignKey('equipment.id'))
effect = db.Column(db.Integer, db.ForeignKey('equipment_effect.id'))
feature = db.Column(db.Integer, db.ForeignKey('features.id'))
dc = db.Column(db.Integer)
skill_type = db.Column(db.Integer, db.ForeignKey('skills.id'))
skill = db.Column(db.Integer, db.ForeignKey('skill_bonus.id'))
check = db.Column(db.Integer, db.ForeignKey('checks.id'))
when = db.Column(db.String())
condition1 = db.Column(db.String())
condition2 = db.Column(db.String())
def format(self):
return {
'id': self.id,
'equip_id': self.equip_id,
'effect': self.effect,
'feature': self.feature,
'dc': self.dc,
'skill_type': self.skill_type,
'skill': self.skill,
'check': self.check,
'when': self.when,
'condition1': self.condition1,
'condition2': self.condition2
}
class BurstBlockMixin(object):
"""
平台爆块记录
"""
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
account_key = db.Column(db.String(255), index=True)
plotter_id = db.Column(db.String(255))
block_hash = db.Column(db.String(256), default='')
nonce = db.Column(db.String(256), default='')
height = db.Column(db.INTEGER)
burst_block_time = db.Column(db.BIGINT)
create_time = db.Column(db.TIMESTAMP(), default=datetime.now)
def to_dict(self):
burst_dict = {
"account_key": self.account_key,
"plotter_id": self.plotter_id,
"block_hash": self.block_hash,
"nonce": self.nonce,
"height": self.height,
"deadline": self.deadline,
"create_time": str(self.create_time),
"burst_block_time": self.burst_block_time,
}
return burst_dict
class AssetTransfer(db.Model):
__tablename__ = 'pool_asset_transfer'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
account_key = db.Column(db.String(64), index=True)
amount = db.Column(db.DECIMAL(32, 16))
direction = db.Column(db.BOOLEAN, comment="True:抵押到余额，False:余额到抵押")
create_time = db.Column(db.TIMESTAMP(), default=datetime.now)
coin_name = db.Column(db.String(32), default='0')
def __init__(self, account_key, amount, direction, coin_name):
self.account_key = account_key
self.amount = amount
self.direction = direction
self.coin_name = coin_name
def to_dict(self):
transfer_dict = {
"account_key": self.account_key,
"amount": self.amount,
"coin_name": self.coin_name,
"direction": self.direction,
"create_time": str(self.create_time),
}
return transfer_dict
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
# password = db.Column(db.String(64))
password_hash = db.Column(db.String(128))
@property
def password(self):
raise AttributeError('密码不能读取！')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def init_db():
db.drop_all()
db.create_all()
@staticmethod
def init_datas():
user_a = User(username='******', password="******")
user_b = User(username='******', password="******")
user_c = User(username='******', password="******")
db.session.add_all([user_a, user_b, user_c])
db.session.commit()
class Product(db.Model, Base, EntityBase):
__tablename__ = 'product'
id = db.Column(guid(), primary_key=True)
# Relationships with Category
category_id = db.Column(guid(),
db.ForeignKey('category.id',
name='fk_product_id_category',
onupdate='CASCADE',
ondelete='CASCADE'),
index=True)
category = db.relationship('Category')
name = db.Column(db.String(255), nullable=False)
photo = db.Column(db.String(255))
code = db.Column(db.String(255), nullable=False)
price = db.Column(db.Numeric(10, 2), nullable=False)
quantity = db.Column(db.Integer, nullable=False, default=0)
description = db.Column(db.Text)
@property
def entity_type(self):
return EntityBase.TYPE_PRODUCT
@property
def resource_type(self):
from models.acl import AclResource
return AclResource.PRODUCT
class DeadlineFractionMixin(object):
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
account_key = db.Column(db.String(64), index=True)
plotter_id = db.Column(db.String(64), index=True)
miner_name = db.Column(db.String(64), index=True)
fraction = db.Column(db.DECIMAL(32, 16))
capacity = db.Column(db.DECIMAL(32, 16))
height = db.Column(db.INTEGER)
create_time = db.Column(db.TIMESTAMP(), default=datetime.now)
deadline = db.Column(db.BigInteger)
def to_dict(self):
dl_fraction_dict = {
"account_key": self.account_key,
"plotter_id": self.plotter_id,
"miner_name": self.miner_name,
"fraction": self.fraction,
"capacity": self.capacity,
"height": self.height,
"create_time": str(self.create_time),
"deadline": self.deadline,
}
return dl_fraction_dict
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 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 Site(db.Model):
__tablename__ = "site"
key = db.Column(db.String(64), primary_key=True)
value = db.Column(db.String(64))
def __repr__(self):
return '<Site %s>' % self.key
class Department(db.Model):
""" Departments table. """
__tablename__ = 'departments'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
avg_salary = db.Column(db.Float, nullable=False, default=0.0)
count_employees = db.Column(db.Integer, nullable=False, default=0)
email = db.Column(db.String(64))
def __init__(self, name: str, email: str = None):
self.name = name.strip()
self.email = email.strip()
self.avg_salary = 0.0
self.count_employees = 0
logger.debug(
'Created Department instance. Department name is %s, '
'email = %s, average salary = %f, employees = %i', self.name,
self.email, self.avg_salary, self.count_employees)
# def __eq__(self, other):
# if not isinstance(other, Department):
# return NotImplemented
# return self.id == other.id\
# and self.name == other.name \
# and self.avg_salary == other.avg_salary \
# and self.count_employees == other.count_employees \
# and self.email == other.email
def __repr__(self):
return f'<Department {self.name}, {self.email}'
class User(BaseModel):
name = db.Column(db.String(64), index=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def update(self, **kwargs):
name = kwargs.get('name', self.name)
email = kwargs.get('email', self.email)
password = kwargs.get('password')
self.name = name
self.email = email
if password:
self.set_password(password)
@property
def serialize(self):
return dict(
id=self.id,
name=self.name,
email=self.email
)
def __repr__(self):
return '<User %r>' % self.name
class VehicleModel(db.Model):
id: int = db.Column(db.Integer, primary_key=True)
client_id = db.Column(db.Integer, db.ForeignKey('client.id'))
brand: str = db.Column(db.String(30), nullable=False)
model: str = db.Column(db.String(30), nullable=False)
board: str = db.Column(db.String(30), nullable=False, unique=True)
year: str = db.Column(db.String(30), nullable=False)
@staticmethod
def list_all():
return VehicleModel.query.order_by(VehicleModel.id).all()
@staticmethod
def get_by_client(client_id):
return VehicleModel.query.filter_by(client_id=client_id).all()
@staticmethod
def get_by_board(board):
return VehicleModel.query.filter_by(board=board).first()
@staticmethod
def get_by_id(id):
return VehicleModel.query.filter_by(id=id).first()
def save(self):
db.session.merge(self)
db.session.commit()
