Example #1
0
class User(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, autoincrement=True, primary_key=True)
    name = db.Column(db.String(20), nullable=False, unique=True)
    password = db.Column(db.String(100), nullable=False)
    gender = db.Column(db.Enum("M", "N", "F"), nullable=False, default='N')
    birthday = db.Column(db.Date)
    recognition = db.Column(db.String(20))
    is_admin = db.Column(db.Enum("Y", "N"), nullable=False, default='N')
    level = db.Column(db.Integer, nullable=False, default=1)
    exp = db.Column(db.Integer, nullable=False, default=0)
    pic = db.Column(db.String(100),
                    nullable=False,
                    default='images/userdefault.png')
    balance = db.Column(db.Integer, nullable=False, default=0)
Example #2
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'

    # 这里不要使用自增长的主键,否则可以很轻松获得该系统的用户数
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(
        db.String(100),
        default='https://www.yingjoy.cn/wp-content/uploads/2017/08/1.jpg')
    signature = db.Column(db.String(100), default='此人较懒...')
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    join_time = db.Column(db.DateTime, default=datetime.now)

    def __init__(self, *args, **kwargs):
        if 'password' in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop('password')
        super(FrontUser, self).__init__(*args, **kwargs)

    @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)
Example #3
0
class Task(db.Model):
    __tablename__ = 'task'
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    # task名称
    title = db.Column(db.String(30), nullable=False)
    # task详情
    content = db.Column(db.String(100))
    # 全天时间,默认为否
    all_day = db.Column(db.Boolean, default=False)
    # 开始时间,默认为创建时间
    start = db.Column(db.DateTime, default=datetime.now)
    # 结束时间,可以为空,fullcalendar自动设置为开始时间1小时后
    end = db.Column(db.DateTime)
    # 是否邮件提醒,默认提醒
    email_remind = db.Column(db.Boolean, default=True)
    # 是否短信提醒,默认不提醒
    message_remind = db.Column(db.Boolean, default=False)
    # 短信提醒时间
    remindtime = db.Column(db.DateTime, default=datetime.now)
    # task完成状态,
    status = db.Column(db.Enum(TaskStatusEnum),
                       default=TaskStatusEnum.UNFINISHED)
    # 对应用户
    user_id = db.Column(db.String(100),
                        db.ForeignKey('front_user.id'),
                        nullable=False)
Example #4
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'
    # 用户id设置自增长的话容易被人猜出用户数量,使用生成随机数的方式,同时呢避免id重复
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    username = db.Column(db.String(50), nullable=False)
    tel = db.Column(db.String(11), nullable=False, unique=True)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))  # 真实姓名
    avatar = db.Column(db.String(100))  # 头像
    signature = db.Column(db.String(100))  # 个性签名
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKOWN)
    is_display = db.Column(db.Integer,
                           default=1,
                           comment='默认1允许用户发帖,0表示不允许用户发帖')
    join_time = db.Column(db.DateTime, default=datetime.now)

    def __init__(self, *args, **kwargs):
        if "password" in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop('password')
        super().__init__(*args, **kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, newpad):
        self._password = generate_password_hash(newpad)

    def check_password(self, rawpwd):
        result = check_password_hash(self.password, rawpwd)
        return result
Example #5
0
class FrontUser(db.Model):
    __tablename__='front_user'
    id=db.Column(db.String(100),primary_key=True,default=shortuuid.uuid)
    telephone=db.Column(db.String(11),nullable=False,unique=True)
    username=db.Column(db.String(50),nullable=False)
    _password=db.Column(db.String(100),nullable=False)
    email=db.Column(db.String(50),unique=True)
    realname=db.Column(db.String(50))
    avatar=db.Column(db.String(100))
    signature=db.Column(db.String(100))
    gender=db.Column(db.Enum(GenderEnum),default=GenderEnum.UNKNOWN)
    join_time=db.Column(db.DateTime,default=datetime.now)

    def __init__(self,*args,**kwargs):
        if 'password' in kwargs:
            self.password=kwargs.get('password')
            kwargs.pop('password')
        super(FrontUser, self).__init__(*args,**kwargs)



    @property
    def password(self):
        return self._password

    @password.setter
    def password(self,newpwd):
        self._password=generate_password_hash(newpwd)

    def check_password(self,rawpwd):
        return check_password_hash(self._password,rawpwd)
Example #6
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'
    id = db.Column(db.String(100), primary_key=100, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    password_hash = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOWN)
    join_time = db.Column(db.DateTime, default=datetime.now)
    posts = db.relationship('PostModel', backref='front_users')
    comments = db.relationship('Comment', backref='front_users')

    def __init__(self, *args, **kwargs):
        if "password" in kwargs:
            self.password = kwargs.get("password")
            kwargs.pop("password")
        super(FrontUser, self).__init__(*args, **kwargs)

    @property
    def password(self):
        raise AttributeError('password is not a readable attribute')

    @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)

    def __repr__(self):
        return '<FrontUser {}>'.format(self.username)
Example #7
0
class Front_user(db.Model):     #创建一个前台用户类
    __tablename__='front_user'  #表明
    id=db.Column(db.String(200),primary_key=True)                               #用户id
    username=db.Column(db.String(20),nullable=False)                        #用户名
    telephone=db.Column(db.String(11),nullable=False,unique=True)           #手机号
    __passwd=db.Column(db.String(200),nullable=False)                        #密码
    avatar=db.Column(db.String(200))                                        #头像
    realname=db.Column(db.String(20))                                       #真实姓名
    personal_introduction=db.Column(db.String(150))                         #个人介绍
    gender=db.Column(db.Enum(GenderEnum),default=GenderEnum.unknow)         #性别
    join_time=db.Column(db.DateTime,default=datetime.now())                 #链接时间
    is_delete=db.Column(db.Boolean,default=False,nullable=False)            #用于加入黑名单

    def __init__(self,*args,**kwargs):
        if 'passwd' in kwargs:      #对接受过来的密码进行一段处理
            passwd=kwargs.get('passwd')
            self.passwd=passwd
            kwargs.pop('passwd')  #删除这个passwd
        super(Front_user, self).__init__(*args,**kwargs)    #剩下的内容交个父类处理



    @property           #对密码进行加密
    def passwd(self):
        return self.__passwd
    @passwd.setter
    def passwd(self,passwd):
        self.__passwd=generate_password_hash(passwd)

    def check_passwd(self,passwd):          #查看用户输入的密码是否正确
        return check_password_hash(self.passwd,passwd)
Example #8
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'
    id = db.Column(db.String(100), primary_key=True,
                   default=shortuuid.uuid)  # 自增长对商业信息不好,使用唯一字符串,shortuuid
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKONE)
    join_time = db.Column(db.DateTime, default=datetime.now)

    # 为了命令行中,_password找不到
    def __init__(self, *args, **kwargs):
        if "password" in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop("password")
        super(FrontUser, self).__init__(*args, **kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, raw_pwd):
        # 进行加密
        self._password = generate_password_hash(raw_pwd)

    def check_pwd(self, pwd):
        # 界面并对照
        result = check_password_hash(self.password, pwd)
        return result
Example #9
0
class User(db.Model):
    """前台用户"""
    __tablename__ = 'user'

    id = db.Column(db.String(50), primary_key=True, default=uuid)
    username = db.Column(db.String(50), nullable=False)
    telephone = db.Column(db.String(20), nullable=False, unique=True)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(200))
    realname = db.Column(db.String(50))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.DOKNOW)
    join_time = db.Column(db.DateTime(), default=datetime.now)

    def __init__(self, *args, **kwargs):
        if 'password' in kwargs:
            self.password = kwargs.pop('password')

        super(User, self).__init__(*args, **kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, newpwd):
        self._password = generate_password_hash(newpwd)

    def check_password(self, password):
        return check_password_hash(self.password, password)
Example #10
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'
    #这里的id如果我们还使用自动增长,就会存在商业安全隐患,用户可以根据id推算出我们网站的人数
    #不使用自动增长,又要保证id的唯一性,我们就可以使用uuid
    #虽然UUid好用,但是它太长了,查找效率就会降低
    #这时我们就可以使用shortuuid这个库,它既满足了唯一性,又没有uuid那么长
    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), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenDerEnum), default=GenDerEnum.UNKNOW)
    join_time = db.Column(db.DateTime, default=datetime.now)

    #对password对应的是_password,所以要做处理
    def __int__(self, *args, **kwargs):
        if 'password' in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop('password')
        super(FrontUser, self).__init__(*args, **kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, newpwd):
        self._password = generate_password_hash(newpwd)

    def check_password(self, rawpwd):
        return check_password_hash(self._password, rawpwd)
Example #11
0
class FrontUser(db.Model):
    __tablename__ = "front_user"
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(30), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))  # 头像
    signature = db.Column(db.String(100))  # 签名
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    join_time = db.Column(db.DateTime, default=datetime.datetime.now)

    # 因为要特殊处理password
    def __init__(self, password, **kwargs):
        self.password = password
        kwargs.pop('password', None)
        super(FrontUser, self).__init__(**kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, frontpwd):
        # 1. 密码不希望外界访问 2.防止循环引用
        self._password = generate_password_hash(frontpwd)

    def checkPwd(self, frontpwd):
        # return self.password == generate_password_hash(frontpwd)
        return check_password_hash(self._password, frontpwd)
Example #12
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    join_time = db.Column(db.DateTime, default=datetime.now())
    status = db.Column(db.Boolean, default=True)

    # comments = db.relationship("CommentModel",backref='author',cascade='all')

    def __init__(self, *args, **kwargs):
        if 'password' in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop('password')
        super(FrontUser, self).__init__(*args, **kwargs)

    @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):
        result = check_password_hash(self.password, raw_password)
        return result
Example #13
0
class FrontUser(db.Model):
    __tablename__ = "front_user"
    id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
    uid = db.Column(db.String(100), unique=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(20))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.SECRET)
    join_time = db.Column(db.DATETIME, default=datetime.datetime.now)

    def __init__(self, *args, **kwargs):
        if "password" in kwargs:
            self.password = kwargs.get("password")
        super(FrontUser, self).__init__(*args, **kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, password):
        self._password = generate_password_hash(password)

    def check_password(self, password):
        return check_password_hash(self._password, password)
Example #14
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    # telephone = db.Column(db.String(11), unique=True, nullable=False)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True, nullable=False)
    # 真实姓名
    realname = db.Column(db.String(50))
    # 头像
    avatar = db.Column(db.String(50))
    signature = db.Column(db.String(50))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    join_time = db.Column(db.String(50), default=datetime.now)

    def __init__(self, *args, **kwargs):
        if 'password' in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop('password')
        super(FrontUser, self).__init__(*args, **kwargs)

    # 这个装饰的作用是让函数可以通过属性访问
    @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):
        result = check_password_hash(self.password, raw_password)
        return result
Example #15
0
class FrontUser(db.Model):
    __tablename__ = "front_user"
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    join_time = db.Column(db.DateTime, default=datetime.now)

    def __init__(self, *args, **kwargs):
        # 如果传入的参数里面有‘password’,就单独处理
        if "password" in kwargs:
            self.password = kwargs.get("password")
            # 处理完后把password pop出去
            kwargs.pop("password")
            # 剩下的参数交给父类去处理
        super(FrontUser, self).__init__(*args, **kwargs)

    @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):
        result = check_password_hash(self.password, raw_password)
        return result
Example #16
0
class Employee(db.Model):
    __tablename__ = 'employee'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(100), nullable=False)
    age = db.Column(db.Integer, nullable=False)
    sex = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    hometown = db.Column(db.String(100))
    working_age = db.Column(db.Integer)
    education = db.Column(db.Enum(EducationEnum), default=EducationEnum.UNKNOW)
    certificate = db.Column(db.String(1000))
    resume_score = db.Column(db.Integer)
    interview_score = db.Column(db.Integer)
    total_score = db.Column(db.Integer)
    join_time = db.Column(db.DateTime, default=datetime.now())
    #定义外键
    project_id = db.Column(db.Integer, db.ForeignKey('project.id'))
    hr_id = db.Column(db.Integer, db.ForeignKey('hr_user.id'))

    #ORM层面外键映射
    project = db.relationship('Project',
                              backref=db.backref('emploees', cascade='all'))
    hr = db.relationship('HrUser',
                         backref=db.backref('emploees', cascade='all'))
Example #17
0
class Rule(db.Model):
    __tablename__ = "rule"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    type = db.Column(db.Enum("file", "menu"), nullable=False)
    pid = db.Column(db.Integer, nullable=False, index=True, default=0)
    name = db.Column(db.String(100), unique=True, nullable=False)
    title = db.Column(db.String(50), nullable=False)
    icon = db.Column(db.String(50), nullable=False)
    condition = db.Column(db.String(255), nullable=False)
    remark = db.Column(db.String(255), nullable=False)
    ismenu = db.Column(db.SmallInteger, nullable=False)
    createtime = db.Column(db.Integer, nullable=False)
    updatetime = db.Column(db.Integer, nullable=False)
    weigh = db.Column(db.Integer, nullable=False, index=True, default=0)
    status = db.Column(db.String(30), nullable=False)
Example #18
0
class UserModel(db.Model):                      #用户表
    __tablename__='user'
    id=db.Column(db.String(200),primary_key=True,default=shortuuid.uuid)     #用户id
    username=db.Column(db.String(50),nullable=False)                    #用户名
    __passwd=db.Column(db.String(255),nullable=False)                   #用户密码
    mobile = db.Column(db.String(11), nullable=False, unique=True)      #手机号码
    is_delete=db.Column(db.String(255),nullable=True)                   #是否拉黑
    avatar = db.Column(db.String(200))                                  #头像
    personal_introduction = db.Column(db.String(150))                   #个人介绍
    Email = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.unknow)  #性别
    create_time=db.Column(db.DateTime,default=datetime.now())           #创建时间
    money=db.Column(db.Integer,default=0)                               #金钱

    def __init__(self,*args,**kwargs):
        if 'passwd' in kwargs:      #对接受过来的密码进行一段处理
            passwd=kwargs.get('passwd')
            self.passwd=passwd
            kwargs.pop('passwd')  #删除这个passwd
        super(UserModel, self).__init__(*args,**kwargs)    #剩下的内容交个父类处理


    def to_dic(self):
        d={
            'id':self.id,
            'username':self.username,
            'mobile':self.mobile,
            'avatar':self.avatar,
            'personal_introduction':self.personal_introduction,
            # 'gender':self.gender,
            'create_time':self.create_time,
            'money':self.money,
            'email':self.Email
        }
        return d



    @property                                               #对密码进行加密
    def passwd(self):
        return self.__passwd
    @passwd.setter
    def passwd(self,passwd):
        self.__passwd=generate_password_hash(passwd)

    def check_passwd(self,passwd):                          #查看用户输入的密码是否正确
        return check_password_hash(self.passwd,passwd)
Example #19
0
class OrderModel(db.Model):  #订单模型
    __tablename__ = 'order'
    id = db.Column(db.Integer, primary_key=True, nullable=False)  #订单编号
    number = db.Column(db.Integer, nullable=False)  #商品的数量
    good_price = db.Column(db.Integer, nullable=False)  #商品的总价
    status = db.Column(db.Enum(StatusEnum), default=StatusEnum.WAIT_PAY)  #订单状态
    comment = db.Column(db.Text)  #评论信息,或者拒绝理由
    create_time = db.Column(db.DateTime,
                            default=datetime.now(),
                            nullable=False)  #下单时间
    remark = db.Column(db.Text)  #下单备注

    address_id = db.Column(db.Integer,
                           db.ForeignKey('rcaddress.id'),
                           nullable=False)  #地址id
    user_id = db.Column(db.String(255),
                        db.ForeignKey('user.id'),
                        nullable=False)  #下单客户
    goods_id = db.Column(db.Integer, db.ForeignKey('goods.id'),
                         nullable=False)  #商品ID

    address = db.relationship('AddressModel', backref='orders')
    good = db.relationship('GoodsModel', backref='orders')
    user = db.relationship('UserModel', backref='orders')

    def to_dic(self):
        if self.status == StatusEnum.WAIT_PAY:
            status = '待支付'
        elif self.status == StatusEnum.PAID:
            status = '已支付'
        elif self.status == StatusEnum.WAIT_COMMENT:
            statue = '😳评论'
        elif self.status == StatusEnum.COMPLETE:
            status = '已完成'
        elif self.status == StatusEnum.CANCEL:
            status = '已取消'
        d = {
            'id': self.id,
            'number': self.number,
            'goods_price': self.good_price,
            'status': status,
            'create_time': self.create_time,
            'remark': self.remark,
            'goodsName': self.good.title,
        }
        return d
Example #20
0
class Comment(db.Model):
    __tablename__ = 'comments'
    id = db.Column(db.Integer, autoincrement=True, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    author_id = db.Column(db.Integer,
                          db.ForeignKey('users.id'),
                          nullable=False)
    post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
    floor = db.Column(db.Integer, nullable=False)
    parent = db.Column(db.Integer)
    com_time = db.Column(db.DateTime, nullable=False, default=datetime.now)
    like_num = db.Column(db.Integer, nullable=False, default=0)
    status = db.Column(db.Enum("normal", "blocked", "hot"),
                       nullable=False,
                       default="normal")

    author = db.relationship('User', backref=db.backref('comments'))
    article = db.relationship('Post', backref=db.backref('comments'))
Example #21
0
class Post(db.Model):
    __tablename__ = 'posts'
    id = db.Column(db.Integer, autoincrement=True, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    post_day = db.Column(db.Date, nullable=False, default=date.today())
    author_id = db.Column(db.Integer,
                          db.ForeignKey('users.id'),
                          nullable=False)
    board_id = db.Column(db.Integer,
                         db.ForeignKey('boards.id'),
                         nullable=False)
    com_num = db.Column(db.Integer, nullable=False, default=0)
    favor_num = db.Column(db.Integer, nullable=False, default=0)
    reward = db.Column(db.Integer, nullable=False, default=0)
    status = db.Column(db.Enum("reviewing", "normal", "blocked", "hot"),
                       nullable=False,
                       default="reviewing")

    author = db.relationship('User', backref=db.backref('articles'))
    board = db.relationship('Board', backref=db.backref('articles'))
Example #22
0
class Front_User(db.Model):
    __tablename__ = "front_user"
    # id 类型不用db.Integer类型,使用String是为了防止爆破,同时使用shortuuid进行加密
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)  # 非空唯一
    username = db.Column(db.String(150), nullable=False)
    _password = db.Column(db.String(150), nullable=False)  # 密码加密操作修改字段
    email = db.Column(db.String(50), unique=True)

    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(150))  # 头像,二进制数据
    signatrue = db.Column(db.String(500))  # 签名
    gender = db.Column(db.Enum(GenderEnum),
                       default=GenderEnum.UNKNOW)  # 性别枚举类,默认未知
    join_time = db.Column(db.DateTime, default=datetime.now)  # 默认当前时间

    # 修改密码加密操作,manage.py映射数据库时候,使用字段保持相同,由于字段太多,使用传参形式
    def __init__(self, *args, **kwargs):
        if 'password' in kwargs:  # 如果传参中包含有
            self.password = kwargs.get('password')  # 获取该参数值赋值给password
            kwargs.pop('password')  # 模型参数中是_password,不是password,弹出

        # super(FrontUser, self).__init__(*args, **kwargs)   # python2的写法
        super().__init__(*args, **kwargs)

    # 密码加密操作
    @property
    def password(self):  # 密码取值
        return self._password

    @password.setter  # 密码加密
    def password(self, raw_password):
        self._password = generate_password_hash(raw_password)

    # 用于验证前台登录密码是否和数据库一致,raw_password是前台登录输入的密码
    def check_password(self, raw_password):
        result = check_password_hash(
            self.password,
            raw_password)  # 相当于用相同的hash加密算法加密raw_password,检测与数据库中是否一致
        return result
Example #23
0
class FrontUser(db.Model):
    __tablename__="front_user"
    id=db.Column(db.String(30),primary_key=True,default=shortuuid.uuid)
    telephone=db.Column(db.String(11),nullable=False,unique=True)
    username=db.Column(db.String(50),nullable=False)
    _password=db.Column(db.String(100),nullable=False)
    email=db.Column(db.String(50),unique=True)
    realname=db.Column(db.String(50))
    avatar=db.Column(db.String(100))
    signature=db.Column(db.String(100))
    gender=db.Column(db.Enum(GenderEnum),default=GenderEnum.UNKNOW)
    join_time=db.Column(db.DateTime,default=datetime.now)


    @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)
Example #24
0
class FrontUser(db.Model, UserMixin):
    """
    定义一个类名,系统将类转换为表格,表名为front_user
    定义类的属性就是表格的字段名
    为了安全性,可以将用户表的password属性置为保护属性如    _password
    为了方便用户操作保护属性像操作普通属性一样,需要装饰 _password
    在设置密码的过程中,需要对密码加密——>调用generate_password_hash()
    另外定义一个校验密码的方法check_password()
    在校验密码的过程中,需要对密码解密——>调用check_password_hash()
    """
    __tablename__ = "front_user"
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), unique=True, nullable=False)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOWN)
    join_time = db.Column(db.DateTime, default=datetime.now)

    def __init__(self, *args, **kwargs):
        if "password" in kwargs:
            self.password = kwargs.get("password")
            kwargs.pop("password")
        super().__init__(*args, **kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, newpwd):
        self._password = generate_password_hash(newpwd)

    def check_password(self, rawpwd):
        return check_password_hash(self._password, rawpwd)
Example #25
0
class FrontUser(db.Model):

    __tablename__ = 'front_user'

    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=True)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    # 头像
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    join_time = db.Column(db.DateTime, default=datetime.now)

    works = db.relationship('WorkModel', backref='writer')

    def __init__(self, *args, **kwargs):
        if 'password' in kwargs:
            self.password = kwargs.get('password')
            # 把 password 取出来之后,从 kwargs 中去掉
            kwargs.pop('password')
        super(FrontUser, self).__init__(*args, **kwargs)

    # password属性(方法)获取值
    @property
    def password(self):
        return self._password

    # password属性(方法)赋值
    @password.setter
    def password(self, raw_password):
        self._password = generate_password_hash(raw_password)

    def check_password(self, raw_password):
        result = check_password_hash(self.password, raw_password)
        return result
Example #26
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'

    # id不能为自增长,因为存在商业风险,特别是id关联的url
    id = db.Column(
        db.String(100), primary_key=True, default=shortuuid.uuid
    )  # 这里uuid不加(),如果给了就是每次都是把执行结果当作id,而现在的需求是每次执行产生一个
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    _password = db.Column(db.String(100), nullable=False)  # 加入_后,变成受保护属性
    email = db.Column(db.String(50), nullable=True, unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOWN)
    join_time = db.Column(db.DateTime, default=datetime.now)

    # 初始化
    def __init__(self, *args, **kwargs):
        # kwargs是关键字参数,等同于字典
        if "password" in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop('password')

        # 其他参数可以用父类去处理
        super(FrontUser, self).__init__(*args, **kwargs)

    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, newpwd):
        self._password = generate_password_hash(newpwd)

    def check_password(self, rawpwd):
        return check_password_hash(self._password, rawpwd)
Example #27
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'
    id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
    telephone = db.Column(db.String(11), nullable=False, unique=True)
    username = db.Column(db.String(50), nullable=False)
    # 加密后的密码
    _password = db.Column(db.String(100), nullable=False)
    email = db.Column(db.String(50), unique=True)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100))
    signature = db.Column(db.String(100))
    # 使用枚举,设定默认值为类下的属性
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
    # 此处使datetime.now,而不是datetime.now(),实例化对象时会自动计算时间,而后
    # 者在模型创建刚使用时的时间
    join_time = db.Column(db.DateTime, default=datetime.now)

    def __init__(self, *args, **kwargs):
        if "password" in kwargs:
            # kwargs属于字典,这里可以调用字典的内建方法,get,pop,其他内建方法有:
            #调用password函数,返回的self._password
            self.password = kwargs.get('password')
            kwargs.pop("password")
        #super的作用:将除去password的数据提交给父类去处理
        super(FrontUser, self).__init__(*args, **kwargs)

    # 使用装饰器,将函数定义为属性,这里一方面为上面初始化时调用,另一方面为后面给属性增加方法
    @property
    def password(self):
        return self._password

    @password.setter
    def password(self, newpwd):
        self._password = generate_password_hash(newpwd)

    def check_password(self, rawpwd):
        return check_password_hash(self._password, rawpwd)
Example #28
0
class Role(db.Model):
    __tablename__ = 'role'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    u_id = db.Column(db.String(100), db.ForeignKey('user.id'))
    group = db.Column(db.Enum(Group), default=Group.FrontUser, nullable=False)
    permissions = db.Column(db.Integer, nullable=False)
    user = db.relationship('User', backref=db.backref('role', uselist=False))
    default_group = 'FrontUser'

    def __init__(self, **kwargs):
        super(Role, self).__init__(**kwargs)
        if self.group is None:
            self.group = self.default_group
        if self.permissions is None:
            self.permissions = sum(getattr(Group, self.group, 0).value)
        else:
            self.permissions = min(sum(getattr(Group, self.group).value),
                                   self.permissions)

    def add_permission(self, *perms):
        for perm in perms:
            if not self.has_permission(perm):
                self.permissions += perm

    def remove_permission(self, *perms):
        for perm in perms:
            if self.has_permission(perm):
                self.permissions -= perm

    def reset_permissions(self):
        self.permissions = sum(getattr(Group, self.group).value)

    def has_permission(self, perm):
        return self.permissions & perm == perm

    def __repr__(self):
        return '<Role:%r>' % self.group
Example #29
0
class FrontUser(db.Model):
    __tablename__ = 'front_user'

    id = db.Column(db.String(25),
                   primary_key=True,
                   unique=True,
                   default=shortuuid.uuid)
    name = db.Column(db.String(20), nullable=False)
    _password = db.Column(db.String(200), nullable=False)
    mobile = db.Column(db.String(15), nullable=False, unique=True)
    email = db.Column(db.String(30), unique=True)
    gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOWN)
    avatar = db.Column(db.String(150), default=DEFAULT_AVATAR)
    signature = db.Column(db.String(50))
    realname = db.Column(db.String(10))
    join_time = db.Column(db.DateTime, default=datetime.now)

    def __init__(self, *args, **kwargs):
        if 'password' in kwargs:
            self.password = kwargs.get('password')
            kwargs.pop('password')
        super(FrontUser, self).__init__(*args, **kwargs)

    @property
    def password(self):
        # 通过property将password转化为方法, 以便进行操作后再存储
        return self._password

    @password.setter
    def password(self, raw_password):
        # setter装饰器可以在创建类时取代init
        self._password = generate_password_hash(raw_password)

    def check_password(self, raw_password):
        result = check_password_hash(self.password, raw_password)
        return result
Example #30
0
class User(db.Model):
    __tablename__ = "user"
    id = db.Column(db.String(100),primary_key=True,default=shortuuid.uuid)
    zxbh = db.Column(db.String(50),nullable=False,unique=True)
    username = db.Column(db.String(50),nullable=False)
    _password = db.Column(db.String(100),nullable=False)
    realname = db.Column(db.String(50))
    avatar = db.Column(db.String(100), default='image/avatar/default.png')
    signature = db.Column(db.String(100))
    gender = db.Column(db.Enum(GenderEnum),default=GenderEnum.UNKNOW)
    join_time = db.Column(db.DateTime,default=datetime.now)

    def __init__(self, *args, **kwargs):
        # 如果传入的参数里面有‘password’,就单独处理
        if "password" in kwargs:
            self.password = kwargs.get("password")
            # 处理完后把password pop出去
            kwargs.pop("password")
            # 剩下的参数交给父类去处理
        super(User, self).__init__(*args,**kwargs)

    @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):
        result = check_password_hash(self.password, raw_password)
        return result

    @property
    def permissions(self):
        # 用户拥有的权限
        if not self.roles:
            return 0
        all_permissions = 0
        # 用户所有的角色
        for role in self.roles:
            # 取出用户所有角色的所有权限
            permissions = role.permissions
            # 把所有权限通过“|=”整合到all_permissions
            all_permissions |= permissions

        return all_permissions

    def has_permission(self, permission):
        # 判断用户是否有'xxx'权限
        # 通过与操作判断用户是否有权限,结果相同返回true,不相等返回false
        return self.permissions & permission == permission

    @property
    def is_developer(self):
        return self.has_permission(Permission.ALL_PERMISSION)

    def is_voted(self, post_id):
        for post in self.postvote:
            if post.post_id == post_id:
                return True
        return False