class GithubAccessHistory(db.Model): """History of Github access permission by Admins on Staffs. Contains all the detailed invoked or revoked histories of github permission on staffs. The action field will contain any comments about the action such as invoked permission, revoked permission, cancelled pending, etc. This model is backreferenced by Admin through action_by field, and Staff through action_on field. Therefore, the Admin and the Staff related to a particular history should be supplied to the initializer through the respected arguments. admin_id and staff_id will then automatically contain the ids of respective models related to the particular history. """ __tablename__ = 'githubaccesshistory' id = db.Column(db.Integer, primary_key=True) action = db.Column(db.String(128), nullable=False) datetime = db.Column(db.DateTime, nullable=False) admin_id = db.Column(db.Integer, db.ForeignKey('admins.id')) staff_id = db.Column(db.Integer, db.ForeignKey('staffs.id')) def __init__(self, action, datetime, action_by, action_on): self.action = action self.datetime = datetime self.action_by = action_by self.action_on = action_on
class GatewayModel(CRUDMixin, HelperMixin, db.Model): __tablename__ = 'gateway_model' id = db.Column(db.Integer, primary_key=True) gateway_id = db.Column(db.Integer, db.ForeignKey('gateway.id', ondelete='CASCADE', onupdate='CASCADE'), unique=True, index=True, nullable=False) model_id = db.Column(db.Integer, db.ForeignKey('data_model.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) created_at = db.Column(db.DateTime, default=utils.get_utc_now) gateway = db.relationship('Gateway', backref=db.backref('gateway_model', lazy='joined'), lazy='joined') data_model = db.relationship('DataModel', backref=db.backref('gateway_model', lazy='joined'), lazy='joined') def __init__(self, gateway_id=None, model_id=None): self.gateway_id = gateway_id self.model_id = model_id def __repr__(self): return "<GatewayModel(id='%s',gateway_id='%s',model_id='%s',created_at='%s')>" % ( str(self.id), str(self.gateway_id), str( self.model_id), str(self.created_at))
class User(CRUDMixin, HelperMixin, db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.VARCHAR(20)) password = db.Column(db.VARCHAR(64)) phone = db.Column(db.VARCHAR(15)) gateway_id = db.Column(db.Integer, db.ForeignKey('gateway.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) gateway = db.relation('Gateway', backref='user', lazy=False) created_at = db.Column(db.DateTime, default=utils.get_utc_now) def __init__(self, username=None, password=None, gateway_id=None, phone=None): self.username = username self.password = password self.gateway_id = gateway_id self.phone = phone def __repr__(self): return "<User(id='%s',username='******',password='******',gateway_id='%s',created_at='%s')>" % ( str(self.id), self.username, self.password, self.gateway_id, str(self.created_at))
class HisWeather(CRUDMixin, HelperMixin, db.Model): __tablename__ = 'his_weather' id = db.Column(db.Integer, primary_key=True) publish_date = db.Column(db.DATE) created_at = db.Column(db.DateTime, default=utils.get_utc_now) region_id = db.Column(db.Integer, db.ForeignKey('gateway.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) temperature = db.Column(db.FLOAT) humidity = db.Column(db.FLOAT) weather = db.Column(db.VARCHAR(45)) def __init__(self, publish_date=None, region_id=None, temperature=None, humidity=None, weather=None): self.publish_date = publish_date # self.created_at = created_at self.region_id = region_id self.temperature = temperature self.humidity = humidity self.weather = weather def __repr__(self): return "<HisWeather(id='%s',publish_date='%s',created_at='%s',region_id='%s',temperature='%s',humidity='%s'," \ "weather='%s')>" % (str(self.id), str(self.publish_date), str(self.created_at), str(self.region_id), str(self.temperature), str(self.humidity), self.weather)
class PredictedPower(CRUDMixin, HelperMixin, db.Model): __tablename__ = 'predicted_power' id = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime, default=utils.get_utc_now) region_id = db.Column(db.Integer, db.ForeignKey('gateway.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) predict_date = db.Column(db.DATE) publish_date = db.Column(db.DATE) order = db.Column(db.Integer) power = db.Column(db.FLOAT) def __init__(self, region_id=None, predict_date=None, publish_date=None, order=None, power=None): self.publish_date = publish_date self.region_id = region_id self.predict_date = predict_date self.order = order self.power = power def __repr__(self): return "<PredictedPower(id='%s',created_at='%s',region_id='%s',predict_date='%s',order='%s',power='%s')>" % \ (str(self.id), str(self.created_at), str(self.region_id), str(self.predict_date), str(self.order), str(self.power))
class Staff(db.Model): """Staff model for the staffs. Staff is a simple model for the staffs, where each staff is identified by his email. It contains a github_status field which contains the current access status of the staff to the organization's github repositories. This field can contain one of the following values: 1. 'uninvited': the staff has not been invited yet 2. 'pending': the staff is invited but not accepted invitation 3. 'granted': the staff has access to the github repos This model is backreferenced by an Admin who created the Staff. During initialization, it is required to pass the Admin through added_by parameter. Any history of invoked or revoked permissions on this Staff can be accessed through github_actions field. """ __tablename__ = 'staffs' id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(128), nullable=False, unique=True) github_status = db.Column(db.String(128), nullable=False) admin_id = db.Column(db.Integer, db.ForeignKey('admins.id')) github_actions = db.relationship('GithubAccessHistory', backref='action_on') def __init__(self, email, added_by, github_status='uninvited'): self.email = email self.github_status = github_status self.added_by = added_by
class ActualWeather(CRUDMixin,HelperMixin,db.Model): __tablename__='actual_weather' id = db.Column(db.Integer,primary_key=True) publish_date = db.Column(db.DATE) created_at = db.Column(db.VARCHAR(100)) region_id = db.Column(db.Integer,db.ForeignKey('region.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) forecast_data = db.Column(db.DATE) order = db.Column(db.Integer) temperature = db.Column(db.FLOAT) humidity = db.Column(db.FLOAT) weather=db.Column(db.VARCHAR(45)) def __init__(self,publish_date=None,created_at=None,region_id=None,forecast_data=None,order=None,temperature=None,humidity=None,weather=None): self.publish_date = publish_date self.created_at = created_at self.region_id = region_id self.forecast_data = forecast_data self.order = order self.temperature = temperature self.humidity = humidity self.weather = weather def __repr__(self): return "<ActualWeather(id='%s',publish_date='%s',created_at='%s',region_id='%s',forecast_data='%s',order='%s',temperature='%s',humidity='%s',weather='%s')>" % ( str(self.id),str(publish_date),str(created_at),str(self.region_id),str(self.forecast_data),str(self.order),str(self.temperature),str(self.humidity),self.weather)
class DataModel(CRUDMixin,HelperMixin,db.Model): __tablename__='data_model' id = db.Column(db.Integer,primary_key=True) dataset_id = db.Column(db.Integer, db.ForeignKey('dataset.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) name = db.Column(db.VARCHAR(100)) algorithm_type = db.Column(db.VARCHAR(50)) serialization = db.Column(db.Integer) description = db.Column(db.VARCHAR(200)) created_at = db.Column(db.DateTime) status = db.Column(db.VARCHAR(1)) dataset = db.relationship('DataSet', backref=db.backref('data_model', lazy='joined'), lazy='joined') def __init__(self,dataset_id=None,name=None,algorithm_type=None,serialization=None,description=None,created_at=None,status=None): self.dataset_id = dataset_id self.name = name self.algorithm_type = algorithm_type self.serialization = serialization self.description = description self.created_at = created_at self.status = status def __repr__(self): return "<DataModel(id='%s',dataset_id='%s',name='%s',algorithm_type='%s',serialization='%s',description='%s',created_at='%s',status='%s')>" % ( str(self.id),str(dataset_id),self.name,self.algorithm_type,self.serialization,self.description,str(self.created_at),str(self.status))
class Blog(db.Model): __tablename__ = 'blog' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(64), unique=True) content = db.Column(db.Text, ) author_id = db.Column(db.Integer, db.ForeignKey('user.id'), comment=u'作者') def __repr__(self): return self.title
class Tree(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64)) # recursive relationship parent_id = db.Column(db.Integer, db.ForeignKey('tree.id')) parent = db.relationship('Tree', remote_side=[id], backref='children') def __str__(self): return "{}".format(self.name)
class Resume(db.Model): id = db.Column(db.Integer, primary_key=True) main_flag = db.Column(db.Boolean, nullable=False) mongo_key = db.Column(db.String(100), nullable=False) user_id = db.Column(db.String(32), db.ForeignKey('user.id')) @property def get_data(self): dictionary = self.__dict__ try: del dictionary['_sa_instance_state'] dictionary['user_id'] = self.user_id.hex except: pass return dictionary
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(120)) text = db.Column(db.Text, nullable=False) date = db.Column(db.Date) # some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/) background_color = db.Column(ColorType) created_at = db.Column(ArrowType, default=arrow.utcnow()) user_id = db.Column(UUIDType(binary=False), db.ForeignKey(User.id)) user = db.relationship(User, foreign_keys=[user_id], backref='posts') tags = db.relationship('Tag', secondary=post_tags_table) def __str__(self): return "{}".format(self.title)
class ActualPower(CRUDMixin,HelperMixin,db.Model): __tablename__='actual_power' id = db.Column(db.Integer,primary_key=True) collect_data = db.Column(db.DATE) region_id = db.Column(db.Integer,db.ForeignKey('region.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) power=db.Column(db.FLOAT) def __init__(self,collect_data=None,region_id=None,power=None): self.collect_data = collect_data self.region_id = region_id self.power = power def __repr__(self): return "<ActualPower(id='%s',collect_data='%s',region_id='%s',power='%s')>" % ( str(self.id),str(created_at),str(self.region_id),str(self.power))
class User(db.Model): id = db.Column(UUIDType(binary=False), default=uuid.uuid4, primary_key=True) # use a regular string field, for which we can specify a list of available choices later on type = db.Column(db.String(100)) # fixed choices can be handled in a number of different ways: enum_choice_field = db.Column(db.Enum(EnumChoices), nullable=True) sqla_utils_choice_field = db.Column(ChoiceType(AVAILABLE_USER_TYPES), nullable=True) sqla_utils_enum_choice_field = db.Column(ChoiceType(EnumChoices, impl=db.Integer()), nullable=True) first_name = db.Column(db.String(100)) last_name = db.Column(db.String(100)) # some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/) email = db.Column(EmailType, unique=True, nullable=False) website = db.Column(URLType) ip_address = db.Column(IPAddressType) currency = db.Column(CurrencyType, nullable=True, default=None) timezone = db.Column(TimezoneType(backend='pytz')) dialling_code = db.Column(db.Integer()) local_phone_number = db.Column(db.String(10)) featured_post_id = db.Column(db.Integer, db.ForeignKey('post.id')) featured_post = db.relationship('Post', foreign_keys=[featured_post_id]) @hybrid_property def phone_number(self): if self.dialling_code and self.local_phone_number: number = str(self.local_phone_number) return "+{} ({}) {} {} {}".format(self.dialling_code, number[0], number[1:3], number[3:6], number[6::]) return @phone_number.expression def phone_number(cls): return sql.operators.ColumnOperators.concat(cast(cls.dialling_code, db.String), cls.local_phone_number) def __str__(self): return "{}, {}".format(self.last_name, self.first_name) def __repr__(self): return "{}: {}".format(self.id, self.__str__())
@phone_number.expression def phone_number(cls): return sql.operators.ColumnOperators.concat(cast(cls.dialling_code, db.String), cls.local_phone_number) def __str__(self): return "{}, {}".format(self.last_name, self.first_name) def __repr__(self): return "{}: {}".format(self.id, self.__str__()) #---<Create M2M table>---# post_tags_table = db.Table('post_tags', db.Model.metadata, db.Column('post_id', db.Integer, db.ForeignKey('post.id')), db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')) ) class Post(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(120)) text = db.Column(db.Text, nullable=False) date = db.Column(db.Date) # some sqlalchemy_utils data types (see https://sqlalchemy-utils.readthedocs.io/) background_color = db.Column(ColorType) created_at = db.Column(ArrowType, default=arrow.utcnow()) user_id = db.Column(UUIDType(binary=False), db.ForeignKey(User.id))
def get_data(self): dictionary = self.__dict__ try: del dictionary['_sa_instance_state'] if dictionary['deadline'] != None: dictionary['deadline'] = str(dictionary['deadline']) dictionary['crawl_date'] = str(dictionary['crawl_date']) dictionary['skill_tag'] = dictionary['skill_tag'].split(',') except: pass return dictionary skills_sector_table = db.Table( 'skill_sector', db.Model.metadata, db.Column('job_skill_id', db.Integer, db.ForeignKey('jobskill.id')), db.Column('job_sector_id', db.Integer, db.ForeignKey('jobsector.id'))) class JobSkill(db.Model): __tablename__ = "jobskill" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(200)) sector = db.relationship('JobSector', secondary=skills_sector_table) def __str__(self): return "{}".format(self.name) @property def get_data(self): dictionary = self.__dict__
class Social(db.Model): id = db.Column(db.String(128), primary_key=True) name = db.Column(db.String(100), primary_key=True) user_id = db.Column(db.String(32), db.ForeignKey('user.id'))
#! coding: utf8 from admin import db from flask_login import UserMixin user_role = db.Table( 'user_role', db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True), db.Column('role_id', db.Integer, db.ForeignKey('role.id'), primary_key=True), ) class User(db.Model, UserMixin): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), unique=True, nullable=False) email = db.Column(db.String(128), unique=True, nullable=False) password = db.Column(db.String(128), nullable=False) is_admin = db.Column(db.Integer, default=0, nullable=False) # 是否管理员 0 不是 1 是 status = db.Column(db.Integer, default=1, nullable=False) # 是否有效 0 无效 1有效 roles = db.relationship( "Role", secondary=user_role, lazy='subquery', backref=db.backref('users', lazy=True), ) # 功能模块-用户关联部分 # 定义一对多关系