class EquipmentIncludeTesSuit(db.Model):
__tablename__ = 'equipment_include_test_suit'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
equipment_id = db.Column(db.Integer,
db.ForeignKey('equipment_management.id'),
nullable=False,
comment="设备ID")
test_case_suit_id = db.Column(db.Integer,
db.ForeignKey('test_case_suit.id'),
comment="测试集ID")
rank = db.Column(db.Integer, nullable=False, comment="执行顺序")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
test_case_suit = db.relationship('TestCaseSuit')
class Element(db.Model):
__tablename__ = 'element'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False, comment="目录名")
type_for_android = db.Column(db.String(30), comment="Android查找方式")
loc_for_android = db.Column(db.String(200), comment="Android信息描述")
type_for_ios = db.Column(db.String(30), comment="IOS查找方式")
loc_for_ios = db.Column(db.String(200), comment="IOS信息描述")
page_id = db.Column(db.Integer, db.ForeignKey('page.id'), comment="所属页面ID")
create_datetime = db.Column(db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
comment="创建时间")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
page = db.relationship('Page', backref=db.backref('element'))
class SecurityFinancialSeriesModel(db.Model):
__tablename__ = 'security_financial_series'
security_id = db.Column(db.String(20), db.ForeignKey('security.id'), primary_key=True)
date_key = db.Column(db.Date, primary_key=True)
sector_id = db.Column(db.Integer, db.ForeignKey('sector.id'))
closing_price = db.Column(db.Float)
volume = db.Column(db.Float)
return_daily = db.Column(db.Float)
return_daily_log = db.Column(db.Float)
return_daily_cumulative = db.Column(db.Float)
return_daily_log_cumulative = db.Column(db.Float)
volatility = db.Column(db.Float)
sharpe_ratio = db.Column(db.Float)
vasicek_ratio = db.Column(db.Float)
mc_expected_loss_gross = db.Column(db.Float)
risk_contribution = db.Column(db.Float)
tail_risk_contribution = db.Column(db.Float)
rorac = db.Column(db.Float)
security = db.relationship('SecurityModel', foreign_keys=[security_id])
@property
def serialize(self):
return {
'security_id': self.security_id,
'date_key': str(self.date_key),
'sector_id': str(self.sector_id),
'closing_price': str(self.closing_price),
'volume': str(self.volume),
'return_daily': str(self.return_daily),
'return_daily_log': str(self.return_daily_log),
'return_daily_cumulative': str(self.return_daily_cumulative),
'return_daily_log_cumulative': str(self.return_daily_log_cumulative),
'volatility': str(self.volatility),
'sharpe_ratio': str(self.sharpe_ratio),
'vasicek_ratio': str(self.vasicek_ratio),
'mc_expected_loss_gross': str(self.mc_expected_loss_gross),
'risk_contribution': str(self.risk_contribution),
'tail_risk_contribution ': str(self.tail_risk_contribution ),
'rorac': str(self.rorac),
}
class Express(db.Model):
__tablename__ = 'express'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
owner_id = db.Column(db.Integer, nullable=False) # 此快递的主人
taker_id = db.Column(db.Integer, nullable=True) # 此快递的代拿人
users = db.relationship('User',
secondary=express_user,
backref=db.backref('expresses')) # 此快递有关的用户
# 首页显示内容
ownername = db.Column(db.String(20), nullable=False)
starting = db.Column(db.String(20), nullable=False)
destination = db.Column(db.String(30), nullable=False)
payment = db.Column(db.Integer, nullable=False)
tips = db.Column(db.String(15), nullable=False)
# 详情页显示内容
express_id = db.Column(db.String(20), nullable=False) # 快递单号
destination_detail = db.Column(db.String(20), nullable=True) # 详细地址，选填
weight = db.Column(db.String(20), nullable=True) # 重量，选填
size = db.Column(db.String(20), nullable=True) # 大小，选填
tips_detail = db.Column(db.Text, nullable=True) # 备注，选填
# 确认代拿后显示
# 联系方式
# owner:
tele_o = db.Column(db.String(11), nullable=True)
wechat_o = db.Column(db.String(20), nullable=True)
qq_o = db.Column(db.String(20), nullable=True)
# taker:
tele_t = db.Column(db.String(11), nullable=True)
wechat_t = db.Column(db.String(20), nullable=True)
qq_t = db.Column(db.String(20), nullable=True)
# 发布、代拿、预计送达时间
time_publish = db.Column(db.String(20), nullable=False)
time_take = db.Column(db.String(20), nullable=True)
time_handover = db.Column(db.String(20), nullable=True)
# 状态：0：等待代拿；1：在路上；2：等待支付
state = db.Column(db.Integer, nullable=False)
class AlertTypeModel(db.Model):
__tablename__ = 'alert_type'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
text_template = db.Column(db.String(1000), nullable=False)
target = db.Column(db.String(1), nullable=False)
search_tags = db.relationship(
'AlertSearchTagModel',
foreign_keys='AlertSearchTagModel.alert_type_id')
@property
def serialize(self):
return {
'id': str(self.id),
'name': self.name,
'text_template': self.text_template,
'target': self.target,
}
class GeographyModel(db.Model):
__tablename__ = 'geography'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
level = db.Column(db.Integer, nullable=False)
parent_id = db.Column(db.Integer, db.ForeignKey('geography.id'))
code = db.Column(db.String(10)) # follow the iso_3166_1, see https://en.wikipedia.org/wiki/ISO_3166-1
parent = db.relationship('GeographyModel', remote_side=[id])
@property
def serialize(self):
return {
'id': str(self.id),
'name': self.name,
'level': str(self.level),
'parent_id': str(self.parent_id),
'code': self.code
}
class User(db.Model):
__tablename__='users'
id = db.Column(db.Integer,primary_key=True,autoincrement=True)
telephone = db.Column(db.String(11),nullable=False)
username = db.Column(db.String(50),nullable=False)
password = db.Column(db.String(100),nullable=False)
questions = db.relationship('Question',backref='author')
def __init__(self,*args,**kwargs):
telephone = kwargs.get('telephone')
username = kwargs.get('username')
password = kwargs.get('password')
self.telephone = telephone
self.username = username
self.password = generate_password_hash(password)
def check_password(self,raw_password):
result = check_password_hash(self.password,raw_password)
return result
class Meet(db.Model):
"""
会议室的信息
"""
__tablename__ = 'meet'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(225))
password = db.Column(db.String(20))
password_hash = db.Column(db.String(225))
meet_portrait = db.Column(db.String(128))
create_time = db.Column(db.DateTime())
start_time = db.Column(db.DateTime())
attachment = db.Column(db.String(225))
end_time = db.Column(db.DateTime())
meet_message = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
msgs = db.relationship('ChatMessage', backref='meets')
# ---password hash
@property
def password(self):
raise AttributeError('password is not a readable attributes')
@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)
# ---password hash
def __init__(self, **kwargs):
super(Meet, self).__init__(**kwargs)
self.create_time = datetime.now()
def __str__(self):
return "<Meet {}> created in {}".format(self.name, self.create_time)
def __repr__(self):
return "<Meet {}> created in {}".format(self.name, self.create_time)
class Button(BaseMixin,Model):
__tablename__ = 'buttons'
name = Column(String(255),nullable=False,unique=True)
type = Column(String(255),nullable=False,default='button')
color = Column(Enum('blue','grey','light-blue','yellow','green','red'),default='grey',nullable=False)
size = Column(Enum('XL','L','M','S','XS'),default='M',nullable=False)
text = Column(String(255))
icon = Column(String(255))
icon_library = Column(String(255))
_endpoint = Column(String(255))
is_link = Column(Boolean,default=False)
icon_id = db.Column(db.Integer,db.ForeignKey('font_icons.id'))
_icon = db.relationship('FontIcon',backref='buttons')
@hybrid_property
def endpoint(self):
return self._endpoint
@endpoint.setter
def endpoint(self,endpoint):
self._endpoint = endpoint
if endpoint:
self.is_link = True
else:
self.is_link = False
def _get_absolute_url(self):
return url_for('admin.view_button',item_id=self.id)
def _get_edit_url(self):
return url_for('admin.view_button',item_id=self.id)
@classmethod
def get_id_by_name(cls,name):
b = cls.query.filter(cls.name==name).first()
if b:
rtn = b.id
else:
rtn = 0
return rtn
class Page(db.Model):
__tablename__ = 'page'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False, comment="页面名")
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
comment="项目id")
parent_directory = db.Column(db.Integer,
nullable=False,
default=0,
comment="父级目录ID")
is_del = db.Column(db.Integer, nullable=False, default=0, comment="是否已删除")
create_datetime = db.Column(db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
comment="创建时间")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
action = db.relationship('Action', backref=db.backref('page'))
class Post(db.Model):
__tablename__ = 'post'
__table_args__ = {'mysql_charset': 'utf8'}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(64))
text = db.Column(db.Text)
publish_date = db.Column(db.DateTime, default=datetime.datetime.now)
publish_able = db.Column(db.String(1))
publish_state = db.Column(db.String(1))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
tag_id = db.Column(db.Integer, db.ForeignKey('tag.id'))
comments = db.relationship('Comment', backref='post', lazy='dynamic')
def __init__(self, title, text, publish_able, tag_id):
self.title = title
self.text = text
self.publish_able = publish_able
self.tag_id = tag_id
def __repr__(self):
return '<Post {}>'.format(self.title)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
telephone = db.Column(db.String(11), nullable=False)
username = db.Column(db.String(50), nullable=False)
_password = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(50), nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
books = db.relationship('Book',
backref=db.backref('users'),
lazy='dynamic')
@property
def password(self):
return self._password
@password.setter
def password(self, raw_password):
self._password = generate_password_hash(raw_password)
def check_password(self, raw_password):
return check_password_hash(self.password, raw_password)
class CompanyEsgFactorModel(db.Model):
__tablename__ = 'company_esg_factor'
company_id = db.Column(db.String(20),
db.ForeignKey('company.id'),
primary_key=True)
esg_factor_id = db.Column(db.Integer,
db.ForeignKey('esg_factor.id'),
primary_key=True)
date_key = db.Column(db.Date, primary_key=True)
score = db.Column(db.Float)
esg_factor = db.relationship('EsgFactorModel',
foreign_keys=[esg_factor_id])
@property
def serialize(self):
return {
'company_id': self.company_id,
'esg_factor_id': str(self.esg_factor_id),
'date_key': str(self.date_key),
'score': str(self.score),
}
class TestSuitStep(db.Model):
__tablename__ = 'test_suit_step'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
rank = db.Column(db.Integer, nullable=False, comment="执行顺序")
test_case_id = db.Column(db.Integer,
db.ForeignKey('test_case.id'),
nullable=False,
comment="用例")
skip = db.Column(db.Integer, nullable=False, comment="是否略过")
test_case_suit_id = db.Column(db.Integer,
db.ForeignKey('test_case_suit.id'),
comment="所属用例集ID")
input_args = db.Column(db.Text, comment="输入参数对象")
create_datetime = db.Column(db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
comment="创建时间")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
test_case = db.relationship('TestCase', backref=db.backref('suit'))
class NovelInfo(db.Model):
__tablename__ = 'novel_info'
__table_args__ = {'mysql_charset': 'utf8mb4'}
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(100), default='')
name = db.Column(db.String(60), default='')
author = db.Column(db.String(30), default='')
description = db.Column(db.Text, default='')
category = db.Column(db.String(20), default='')
last_chapter = db.Column(db.String(30), default='')
keywords = db.Column(db.String(60), default='')
word_count = db.Column(db.Integer, default=0)
createtime = db.Column(db.DateTime, default=datetime.utcnow)
updatetime = db.Column(db.DateTime, default=datetime.utcnow)
img = db.Column(db.String(255), default='')
state = db.Column(db.Enum(NovelState), default=NovelState.start)
chapters = db.relationship('NovelChapter', backref='novel_info')
def to_json(self):
novel_json = {
'id': self.id,
'url': self.url,
'name': self.name,
'author': self.author,
'category': self.category,
'description': self.description,
'last_chapter': self.last_chapter,
'keywords': self.keywords,
'word_count': get_count(self.word_count),
'img': self.img,
'updatetime': json.dumps(self.updatetime, cls=DateTimeEncoder),
'state': get_state(self.state),
'chapters': [c.to_json() for c in self.chapters]
}
return novel_json
class User(db.Model):
__tablename__="user"
id=db.Column(db.Integer,primary_key=True,autoincrement=True)
username=db.Column(db.String(20),nullable=False)
_password=db.Column(db.String(200),nullable=False)
email=db.Column(db.String(20),nullable=False)
create_time=db.Column(db.DateTime,default=datetime.now)
roles=db.relationship("role", backref=db.backref("users"), secondary=role_user)
@property
def getPermission(self):
num=0
for role in self.roles:
num=num | role.permis
return num
def checkPermision(self,permis):
if self.getPermission & permis !=0:
return True
else:
return False
def __init__(self,password,**kwargs):
self.password=password
kwargs.pop("password",None)
super(User,self).__init__(**kwargs)
@property
def password(self):
return self._password
@password.setter
def password(self,frontpwd):
self._password=generate_password_hash(frontpwd)
def checkPwd(self,frontpwd):
return check_password_hash(self._password,frontpwd)
class SecurityModel(db.Model):
__tablename__ = 'security'
id = db.Column(db.String(20), primary_key=True)
name = db.Column(db.String(200), nullable=False)
company_id = db.Column(db.String(20), db.ForeignKey('company.id'), nullable=False)
asset_type_id = db.Column(db.Integer, db.ForeignKey('asset_type.id'), nullable=False)
isin = db.Column(db.String(12))
sedol = db.Column(db.String(7))
cusip = db.Column(db.String(9))
company = db.relationship('CompanyModel', foreign_keys=[company_id])
@property
def serialize(self):
return {
'id': self.id,
'name': self.name,
'company_id': self.company_id,
'asset_type_id': str(self.asset_type_id),
'isin': self.isin,
'sedol': self.sedol,
'cusip': self.cusip,
}
class TestCaseSuit(db.Model):
__tablename__ = 'test_case_suit'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(100), nullable=False, comment="用例集名")
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
comment="所属项目ID")
is_del = db.Column(db.Integer, nullable=False, default=0, comment="是否已删除")
parent_directory = db.Column(db.Integer,
nullable=False,
default=0,
comment="父级目录ID")
create_datetime = db.Column(db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
comment="创建时间")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
suit_step = db.relationship('TestSuitStep',
backref=db.backref('case_suit'),
order_by='TestSuitStep.rank')
class Article(db.Model):
__tablename__ = 'article'
a_id = db.Column(db.Integer, primary_key=True)
a_title = db.Column(db.String(255, 'utf8_bin'),
nullable=False,
info='文章标题')
a_content = db.Column(db.String(10000, 'utf8_bin'),
nullable=False,
info='文章内容')
a_create_time = db.Column(db.DateTime, nullable=False, info='文章创建时间')
c_id = db.Column(db.ForeignKey('category.c_id',
ondelete='RESTRICT',
onupdate='RESTRICT'),
index=True,
info='文章标签')
a_hits = db.Column(db.Integer, info='文章点击量')
a_comments = db.Column(db.Integer, info='文章评论量')
a_picture = db.Column(db.String(300, 'utf8_bin'),
server_default=db.FetchedValue())
c = db.relationship('Category',
primaryjoin='Article.c_id == Category.c_id',
backref='articles')
class Citizen(db.Model):
id = db.Column(db.Integer, primary_key=True)
import_id = db.Column(db.Integer, db.ForeignKey("import.import_id"))
citizen_id = db.Column(db.Integer)
town = db.Column(db.String)
street = db.Column(db.String)
building = db.Column(db.String)
apartment = db.Column(db.Integer)
name = db.Column(db.String)
birth_date = db.Column(db.Date)
gender = db.Column(db.String)
# Many-To-Many relationship
relatives = db.relationship(
"Citizen",
secondary=relationship,
primaryjoin=(id == relationship.c.citizen_id),
secondaryjoin=(id == relationship.c.relative_id),
lazy="dynamic")
def get_age(self):
return relativedelta(datetime.now(), self.birth_date).years
def ensure_relationship(self):
# self.relatives = [getattr(self, "import").get_citizen(relative.citizen_id)
# for relative in self.relatives]
for relative in self.relatives:
if self not in relative.relatives:
relative.relatives.append(self)
def remove_relationship(self):
for relative in self.relatives:
if self in relative.relatives:
relative.relatives.remove(self)
def __repr__(self):
return f"Citizen({self.citizen_id}, import_id={self.import_id}, id={self.id})"
class TestLog(db.Model):
__tablename__ = 'test_log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
equipment_id = db.Column(db.Integer, nullable=False, comment="设备ID")
equipment_title = db.Column(db.String(100), nullable=False, comment="设备")
equipment_args = db.Column(db.Text, comment="设备配置参数")
run_test_result = db.Column(db.Integer,
default=0,
comment="测试执行结果:0失败,1成功")
run_test_start_time = db.Column(
db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
comment="测试执行开始时间")
run_test_end_time = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="测试执行结束时间")
run_test_times = db.Column(db.String(100), default=0, comment="测试执行用时时间")
test_case_suit_log = db.relationship(
'TestCaseSuitLog', order_by='TestCaseSuitLog.run_test_suit_start_time')
class Tag(BaseMixin, db.Model):
__tablename__ = 'tags'
name = db.Column(db.String(100), unique=True)
description = db.Column(db.Text)
icon_id = db.Column(db.Integer,db.ForeignKey('font_icons.id'))
icon = db.relationship('FontIcon',backref='tags')
def __unicode__(self):
return self.name
@staticmethod
def update_tags(tag_list):
for tag in tag_list:
t = Tag.query.filter(Tag.name==tag)
if t is None:
t = Tag()
t.name = tag
t.save()
@property
def link(self):
return url_for('blog.tag_list',tag_id=self.id)
class QueryGroup(db.Model):
__tablename__ = 'query_group'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(32))
variables = db.relationship('VarQueries', back_populates='query')
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(32), nullable=False)
email = db.Column(db.String(32))
pw_hash = db.Column(db.String(128))
login_count = db.Column(db.Integer, default=0)
last_login_ip = db.Column(db.String(64), default='unknown')
last_login_time = db.Column(db.Integer)
roles = db.relationship('Role',
secondary=roles,
backref=db.backref('user', lazy='dynamic'),
passive_deletes=True)
def __init__(self, username, password, email=None):
self.username = username
# self.set_password(password)
self.pw_hash = password
self.email = email
def __repr__(self):
return '<User {}'.format(self.username)
@staticmethod
def verify_auth_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None
except BadSignature:
return None
except TypeError:
return None
user_id = data['id']
user = User.query.get(user_id)
try:
assert (data['time'] == user.last_login_time)
except AssertionError:
return None
return user
def is_authenticated(self):
if isinstance(self, AnonymousUserMixin):
return False
else:
return True
def is_active(self):
return True
def is_anonymous(self):
if isinstance(self, AnonymousUserMixin):
return True
else:
return False
def get_id(self):
return unicode(self.id)
def set_password(self, password):
self.pw_hash = generate_password_hash(password)
def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
return self.pw_hash == password
class User(db.Model, UserMixin, BaseMixin):
__tablename__ = 'users'
bio = db.Column(db.String(128), default='')
name = db.Column(db.String(128), default='')
nickname = db.Column(db.String(128), default='')
email = db.Column(db.String(191), default='')
password = db.Column(db.String(191))
website = db.Column(db.String(191), default='')
github_id = db.Column(db.String(191), default='')
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
icon_color = db.Column(db.String(7))
confirmed_at = db.Column(db.DateTime())
company = db.Column(db.String(191), default='')
avatar_id = db.Column(db.String(20), default='')
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
__table_args__ = (
db.Index('idx_name', name),
db.Index('idx_email', email),
)
def url(self):
return '/user/{}'.format(self.id)
@property
def avatar_path(self):
avatar_id = self.avatar_id
return '' if not avatar_id else '/static/avatars/{}.png'.format(
avatar_id)
def update_avatar(self, avatar_id):
self.avatar_id = avatar_id
self.save()
def upload_avatar(self, img):
avatar_id = generate_id()
filename = os.path.join(UPLOAD_FOLDER, 'avatars',
'{}.png'.format(avatar_id))
if isinstance(img, str) and img.startswith('http'):
r = requests.get(img, stream=True)
if r.status_code == 200:
with open(filename, 'wb') as f:
for chunk in r.iter_content(1024):
f.write(chunk)
else:
img.save(filename)
self.update_avatar(avatar_id)
def follow(self, from_id):
ok, _ = Contact.create(to_id=self.id, from_id=from_id)
if ok:
self._stats = None
return ok
def unfollow(self, from_id):
contact = Contact.get_follow_item(from_id, self.id)
if contact:
contact.delete()
self._stats = None
return True
return False
def is_followed_by(self, user_id):
contact = Contact.get_follow_item(user_id, self.id)
return bool(contact)
class User(UserMixin, db.Model): #用户 ORM注册
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
is_adminenticated = db.Column(db.Boolean, default=False)
institute = db.Column(db.String(128), nullable=False)
real_name = db.Column(db.String(128))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
photo = db.Column(db.String(120))
is_authed = db.Column(db.Boolean, default=False)
posts = db.relationship('Post', backref='author', lazy='dynamic')
section = db.relationship('Section', backref='author', lazy='dynamic')
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_photo(self, photo, token=False):
if not token:
return generate_password_hash(
str(self.id) + photo.split('.')[0]) + '.' + photo.split('.')[1]
self.photo = photo
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 avatar(self, size):
if self.photo:
return "users/" + self.photo
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf-8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class YjVariableInfo(db.Model):
__tablename__ = 'yjvariableinfo'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
variable_name = db.Column(db.String(20))
db_num = db.Column(db.Integer)
address = db.Column(db.Float)
data_type = db.Column(db.String(10))
rw_type = db.Column(db.Integer)
upload = db.Column(db.Integer)
acquisition_cycle = db.Column(db.Integer)
server_record_cycle = db.Column(db.Integer)
note = db.Column(db.String(50))
ten_id = db.Column(db.String(200))
item_id = db.Column(db.String(20))
write_value = db.Column(db.Integer)
area = db.Column(db.Integer)
group_id = db.Column(db.Integer, db.ForeignKey('yjgroupinfo.id'))
values = db.relationship('Value',
backref='yjvariableinfo',
lazy='dynamic',
cascade="delete, delete-orphan")
alarms = db.relationship('VarAlarmInfo',
backref='yjvariableinfo',
lazy='dynamic',
cascade="delete, delete-orphan")
params = db.relationship('Parameter',
backref='yjvariableinfo',
lazy='dynamic',
cascade="delete, delete-orphan")
def __init__(self,
variable_name=None,
group_id=None,
db_num=None,
address=None,
data_type=None,
rw_type=None,
upload=None,
acquisition_cycle=None,
server_record_cycle=None,
note=None,
ten_id=None,
item_id=None,
write_value=None,
area=None):
self.variable_name = variable_name
self.group_id = group_id
self.db_num = db_num
self.address = address
self.data_type = data_type
self.rw_type = rw_type
self.upload = upload
self.acquisition_cycle = acquisition_cycle
self.server_record_cycle = server_record_cycle
self.note = note
self.ten_id = ten_id
self.item_id = item_id
self.write_value = write_value
self.area = area
def __repr__(self):
return '<Variable :ID(%r) Name(%r) >'.format(self.id, self.tag_name)
class User(db.Model):
__tablename__ = 'users'
__table_args__ = {'mysql_charset': 'utf8mb4'}
id = db.Column(db.Integer, primary_key=True)
sex = db.Column(db.SmallInteger, default=2)
nick_name = db.Column(db.String(60), index=True)
password = db.Column(db.String(255))
phone = db.Column(db.String(20))
email = db.Column(db.String(40))
signature = db.Column(db.String(512), default='')
province = db.Column(db.String(20), default='')
city = db.Column(db.String(20), default='')
active = db.Column(db.Boolean())
login_time = db.Column(db.Integer)
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(63))
current_login_ip = db.Column(db.String(63))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users')) #, lazy='dynamic'))
groups = db.relationship('Group',
secondary=group_relationship,
backref='members')
mps = db.relationship('MP', secondary=mp_relationship, backref='users')
friends = db.relationship('User',
secondary=friendship,
primaryjoin=(friendship.c.user_id == id),
secondaryjoin=(friendship.c.friend_id == id),
lazy='dynamic')
def __repr__(self):
return '<User %r>' % self.nick_name
def to_json(self):
json_user = {
'id': self.id,
'nickname': self.nick_name,
'phone': self.phone,
'email': self.email,
'signature': self.signature,
'province': self.province,
'signature': self.signature,
'city': self.city
}
return json_user
def hash_password(self, password):
self.password = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password)
def generate_auth_token(self, expiration=600):
s = Serializer(app.app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
def get(self, id):
return self.query.filter_by(id=id).first()
def update(self):
return session_commit()
@staticmethod
def verify_auth_token(token):
s = Serializer(app.app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
@hybrid_method
def add_friend(self, user):
if not self.is_friend(user):
self.friends.append(user)
user.friends.append(self)
return self
@hybrid_method
def del_friend(self, user):
if self.is_friend(user):
self.friends.remove(user)
user.friends.remove(self)
return self
@hybrid_method
def is_friend(self, user):
return self.friends.filter(
friendship.c.friend_id == user.id).count() > 0
@hybrid_method
def add_group(self, group):
if not self.is_in_group(group):
self.groups.append(group)
@hybrid_method
def del_group(self, group):
if self.is_in_group(group):
self.groups.remove(group)
@hybrid_method
def is_in_group(self, group):
return group in self.groups
class User(UserMixin, db.Model, TrackModifications, Anonymous):
__tablename__ = TABLE_USERS
id = db.Column(db.Integer, primary_key=True)
reset_index = db.Column(db.Integer, nullable=False, default=0)
email = db.Column(db.String(128), nullable=False, unique=True)
is_active = db.Column(db.Boolean, nullable=False, default=False)
password_hash = db.Column(db.String(128))
access = db.Column(db.Integer, nullable=False, default=ACCESS_USER)
activation_code = db.Column(db.String(128), unique=True)
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
first_name = db.Column(db.String(128))
last_name = db.Column(db.String(128))
roles = db.relationship("Role", secondary=TABLE_USER_ROLE)
def get_id(self):
return f"{self.id}-{self.reset_index}"
def __repr__(self):
return f"{self.email}"
def __init__(self, email=None, password=None):
self.email = email
if password:
self.set_password(password)
def set_password(self, password, increment=True):
self.password_hash = generate_password_hash(password)
if self.reset_index is not None and increment:
self.reset_index += 1
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def get_reset_password_token(self, expires_in=SECONDS_QUARTER):
return encode({
"reset_password": self.id,
"exp": time() + expires_in
},
current_app.config["SECRET_KEY"],
algorithm="HS256").decode("utf-8")
@staticmethod
def verify_reset_password_token(token):
try:
user_id = decode(token,
current_app.config["SECRET_KEY"],
algorithms=["HS256"])["reset_password"]
except InvalidTokenError:
return None
return User.query.get(user_id)
@hybrid_property
def is_admin(self):
return self.access == ACCESS_ADMIN
@hybrid_property
def is_board(self):
return self.access == ACCESS_BOARD
@property
def full_name(self):
if self.first_name and self.last_name:
return f"{self.first_name} {self.last_name}"
return self.first_name
@property
def role_names(self):
return [r.name for r in self.roles]
@property
def profile(self):
data = {
"id": self.id,
"email": self.email,
"first_name": self.first_name,
"last_name": self.last_name,
"full_name": self.full_name,
"roles": [r.json() for r in self.roles],
}
return data
def get_auth_token(self, expires_in=SECONDS_DAY):
return encode(
{
"id": self.id,
"reset_index": self.reset_index,
"email": self.email,
"access": self.access,
"first_name": self.first_name,
"last_name": self.last_name,
"full_name": self.full_name,
"roles": [r.json() for r in self.roles],
"iat": time(),
"exp": time() + expires_in,
},
current_app.config["SECRET_KEY"],
algorithm="HS256").decode("utf-8")
class Student(db.Model, BaseModel):
sid = db.Column(db.Integer, primary_key=True, autoincrement=True)
sname = db.Column(db.String(30))
courses = db.relationship('Course', secondary='grade', backref='students')
__tablename__ = 'student'
