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'