class Admin(db.Model, UserMixin):
    """Admin model for the admins.

    The admin model is extended by the UserMixin model supplied by the
    Flask-Login package. The UserMixin model contains several commonly
    used fields like is_authenticated, is_annonymous, and others which
    are commonly needed for authenticating a user.

    The application requires atleast one superadmin throughout its life-
    cycle as only they can create or remove other admins. Default value
    of is_superadmin is false.

    An Admin is related to two other models so far. First one is to a
    Staff through one-to-many relationship. An Admin can create many
    staffs. Another is to the GithubAccessHistory, also through a one-
    to-many relationship. An Admin can invoke or revoke permissions of
    many Staffs many times.

    Any history of invoking or revoking github permissions on any staff
    by the Admin can be accessed through github_actions field.
    """
    __tablename__ = 'admins'
    
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(128), nullable=False, unique=True)
    password = db.Column(db.String(128), nullable=False)
    is_superadmin = db.Column(db.Boolean(), default=True, nullable=False)

    added_staffs = db.relationship('Staff', backref='added_by')
    github_actions = db.relationship('GithubAccessHistory', backref='action_by')

    def __init__(self, email, password, is_super=False):
        self.email = email
        self.password = password
        self.is_superadmin = is_super
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 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    
示例#4
0
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))
示例#5
0
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
示例#6
0
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)
示例#7
0
class DataSet(CRUDMixin, HelperMixin, db.Model):
    __tablename__ = 'dataset'

    id = db.Column(db.Integer, primary_key=True)
    filename = db.Column(db.VARCHAR(255))
    dataformat = db.Column(db.VARCHAR(10))
    title = db.Column(db.VARCHAR(50))
    rows = db.Column(db.Integer)
    columns = db.Column(db.Integer)
    description = db.Column(db.VARCHAR(200))
    uploadtime = db.Column(db.DateTime)
    status = db.Column(db.VARCHAR(10))

    def __init__(self,
                 filename=None,
                 dataformat=None,
                 title=None,
                 rows=None,
                 columns=None,
                 description=None,
                 uploadtime=None,
                 status=None):
        self.filename = filename
        self.dataformat = dataformat
        self.title = title
        self.rows = rows
        self.columns = columns
        self.description = description
        self.uploadtime = uploadtime
        self.status = status

    def __repr__(self):
        return "<DataSet(id='%s',filename='%s',dataformat='%s',title='%s',rows='%s',columns='%s',description='%s'," \
               "uploadtime='%s')>" % (str(self.id), self.filename, self.dataformat, self.title, str(self.rows),
                                      str(self.columns), self.description, str(self.uploadtime), self.status)
示例#8
0
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)
示例#9
0
class Role(db.Model):
    __tablename__ = 'role'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32), unique=True, nullable=False)
    status = db.Column(db.Integer, default=1, nullable=False)  # 是否有效 0 无效 1有效

    def __repr__(self):
        return self.name

    def __str__(self):
        return self.name
示例#10
0
class Test(CRUDMixin, HelperMixin,db.Model):
    __tablename__='test'
    
    id = db.Column(db.Integer,primary_key=True)
    name =  db.Column(db.VARCHAR(20))
    age = db.Column(db.VARCHAR(20))
    
    def __init__(self,name=None ,age=None):
        self.name = name
        self.age = age

    def __repr__(self):
        return "<Test(id='%s',name='%s',age='%s')>" % (str(self.id),self.name,self.age)
示例#11
0
class Gateway(CRUDMixin, HelperMixin, db.Model):
    __tablename__ = 'gateway'
    __table_args__ = {'extend_existing': True}

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.VARCHAR(30))
    url = db.Column(db.VARCHAR(30))
    address = db.Column(db.VARCHAR(50))
    latitude = db.Column(db.VARCHAR(20))
    longitude = db.Column(db.VARCHAR(20))
    status = db.Column(db.Boolean)
    created_at = db.Column(db.DateTime, default=utils.get_utc_now)

    def __init__(self,
                 name=None,
                 url=None,
                 address=None,
                 latitude=None,
                 longitude=None,
                 status=False):
        self.name = name
        self.url = url
        self.address = address
        self.latitude = latitude
        self.longitude = longitude
        self.status = status

    def __repr__(self):
        return "<Gateway(id='%s',name='%s',url='%s',address='%s',latitude='%s', longitude='%s', created_at='%s')>" % (
            str(self.id), self.name, self.url, self.address, self.latitude,
            self.longitude, str(self.created_at))
示例#12
0
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))
示例#13
0
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
示例#14
0
class TokenMapping(db.Model):
    __tablename__ = "user_token_mapping"
    id = db.Column(db.Integer,
                   primary_key=True,
                   nullable=False,
                   unique=True,
                   autoincrement=True)
    uuid = db.Column(db.String(40), nullable=False)
    token = db.Column(db.String(250), nullable=False)
    created = db.Column(db.DateTime, nullable=False, default=datetime.now)
    modified = db.Column(db.DateTime, nullable=False, default=datetime.now)

    def __init__(self, uuid, token):
        self.uuid = uuid
        self.token = token
示例#15
0
class Role(db.Model):
    __tablename__ = 'user_role'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(15), nullable=False)
    cname = db.Column(db.String(30))

    def __init__(self, role_id, name, cname=None):
        self.id = role_id
        self.name = name
        self.cname = cname

    @staticmethod
    def _get_name(role_id):
        role = db.session.query(Role).filter(Role.id == role_id).first()
        return role.cname
示例#16
0
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))
示例#17
0
class JobSector(db.Model):
    __tablename__ = "jobsector"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(200))
    skills = db.relationship('JobSkill', secondary=skills_sector_table)

    def __str__(self):
        return "{}".format(self.name)

    @property
    def get_data(self):
        dictionary = self.__dict__
        try:
            del dictionary['_sa_instance_state']
        except:
            pass
        return dictionary
示例#18
0
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)
示例#19
0
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))
示例#20
0
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))
示例#21
0
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),
    )

    # 功能模块-用户关联部分
    # 定义一对多关系
    # blogs: 一个用户有多个博客,字段:复数
    # author:一篇博客只能属于一个用户,字段:单数
    blogs = db.relationship(
        'Blog',
        backref='author',
    )

    def __repr__(self):
        return self.username
示例#22
0
class Operation(db.Model):
    """
        可以把此看作权限表,但我将其定义为 操作某种资源(资源的定义参考 restfull api设计理念)的一系列动作,
        如 查看  某个 资源, 如 新增 一个资源
        而把 某动作  授予  某个角色,即完成了权限的管理(绑定)
    """
    __tablename__ = 'operation'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)
    method = db.Column(db.String(32), default='GET', )
    uri = db.Column(db.String(256), default='/', nullable=False)

    roles = db.relationship(
        "Role",
        secondary=role_operation,
        lazy='subquery',
        backref=db.backref('operations', lazy=True),
    )

    description = db.Column(db.Text, comment=u'描述信息')

    def __repr__(self):
        return self.name
示例#23
0
class Group(db.Model):
    __tablename__ = 'user_group'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(50), nullable=False)
    cname = db.Column(db.String(100))
    selectors = db.Column(db.Text)

    def __init__(self, name, cname=None, selectors=None):
        self.name = name
        self.cname = cname
        self.selectors = selectors

    def _to_dict(self):
        return {
            col.name: getattr(self, col.name, None)
            for col in self.__table__.columns
        }

    @staticmethod
    def _from_dict(group_dict):
        return Group(name=group_dict.get('name'),
                     cname=group_dict.get('cname'),
                     selectors=group_dict.get('selectors'))
示例#24
0
class Selector(db.Model):
    __tablename__ = 'user_selector'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(50), nullable=False)
    cname = db.Column(db.String(50))
    kind = db.Column(db.String(50))

    def __init__(self, name, cname, kind):
        self.name = name
        self.cname = cname
        self.kind = kind

    def _to_dict(self):
        return {
            col.name: getattr(self, col.name, None)
            for col in self.__table__.columns
        }

    @staticmethod
    def _from_dict(selector_dict):
        return Selector(name=selector_dict.get('name'),
                        cname=selector_dict.get('cname'),
                        kind=selector_dict.get('kind'))
示例#25
0
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)
示例#26
0
class User(db.Model):
    id = db.Column(UUIDType(binary=False),
                   default=uuid.uuid4,
                   primary_key=True)
    password = db.Column(db.String(128))
    auth = db.Column(db.String(100))
    email = db.Column(EmailType, unique=True, nullable=False)
    nickname = db.Column(db.String(100), nullable=False)
    thumbnail = db.Column(URLType, default='/static/img/wdticon.png')
    create_date = db.Column(db.DateTime)
    resume = db.relationship('Resume')

    @property
    def is_authenticated(self):
        return True

    @property
    def is_admin(self):
        if self.auth == u'admin':
            return True
        else:
            return False

    @property
    def is_active(self):
        return True

    @property
    def is_anonymous(self):
        return False

    def get_id(self):
        return self.id

    # Required for administrative interface
    def __unicode__(self):
        return self.username
示例#27
0
class Tag(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.Unicode(64), unique=True)

    def __str__(self):
        return "{}".format(self.name)
示例#28
0
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__())
示例#29
0
    @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))
示例#30
0
#! 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),
    )

    # 功能模块-用户关联部分
    # 定义一对多关系