Example #1
0
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)
Example #2
0
class Comment(db.Model):
    __tablename__ = 'comment'
    __table_args__ = {'mysql_charset': 'utf8'}
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(255), nullable=False)
    text = db.Column(db.Text(), nullable=False)
    date = db.Column(db.DateTime())
    remark = db.Column(db.String(255))
    post_id = db.Column(db.Integer, db.ForeignKey('post.id'))

    def __repr__(self):
        return "<Comment '{}'>".format(self.text[:15])
Example #3
0
class ChatMessage(db.Model):
    """
    记录聊天的message
    """
    __tablename__ = 'chat_message'
    id = db.Column(db.Integer, primary_key=True)
    message = db.Column(db.Text)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    meet_id = db.Column(db.Integer, db.ForeignKey('meet.id'))
    create_time = db.Column(db.DateTime())

    def __init__(self, **kwargs):
        super(ChatMessage, self).__init__(**kwargs)
        self.create_time = datetime.now()

    def __str__(self):
        return "<ChatRoom {}>".format(Meet.query.get(self.meet_id).name)

    def __repr__(self):
        return "<ChatRoom {}>".format(Meet.query.get(self.meet_id).name)
Example #4
0
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)
Example #5
0
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
Example #6
0
class User(db.Model):
    """
    会议的用户表和管理员表
    id  编号
    username  用户名
    password  密码(不可见)
    password_hash 储存password的hash码
    email 仅一个
    phone  电话号码 仅一个
    company  人员所属公司
    meets 关联的会议信息表
    create_time 用户创建时间
    msgs 关联 聊天记录
    verify_password 验证密码
    generate_auth_token 生成token
    verify_auth_token 验证token
    """
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    head_portrait = db.Column(db.String(128), default='file/head_portrait.jpg')
    username = db.Column(db.String(25), unique=True)
    password = db.Column(db.String(25))
    password_hash = db.Column(db.String(225))
    email = db.Column(db.String(30), unique=True)
    phone = db.Column(db.String(15), unique=True)
    company = db.Column(db.String(50))
    meets = db.relationship('Meet', backref='users', lazy='dynamic')
    create_time = db.Column(db.DateTime())
    msgs = db.relationship('ChatMessage', backref='users')
    role_id = db.Column(db.Integer, db.ForeignKey('role.id'))

    # ---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 generate_auth_token(self, expiration=6000):
        s = Serializer(BaseConfig.SECRET_KEY, expires_in=expiration)
        return s.dumps({'id': self.id})

    @staticmethod
    def verify_auth_token(token):
        s = Serializer(BaseConfig.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

    def can(self, permission):
        return self.role is not None and (self.role.permissions
                                          & permission) == permission

    def is_meeter(self):
        """
        判断是否为会议的创建者 permissions == 3
        """
        return self.can(Permission.USER | Permission.MEETER)

    def is_admin(self):
        """
        判断是否系统管理员 permissions == 255
        """
        return self.can(Permission.ADMINISTRATOR)

    def __init__(self, **kwargs):
        super(User, self).__init__(**kwargs)
        self.create_time = datetime.now()

    def __str__(self):
        return "<User: {} id: {}>".format(self.username, self.id)

    def __repr__(self):
        return "<User {} id: {}>".format(self.username, self.id)
Example #7
0
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"))

    _stats = None

    __table_args__ = (db.Index("idx_name", name), db.Index("idx_email", email))

    def url(self):
        return f"/user/{self.id}"

    @property
    def avatar_path(self):
        avatar_id = self.avatar_id
        return "" if not avatar_id else f"/static/avatars/{avatar_id}.png"

    def update_avatar(self, avatar_id):
        self.avatar_id = avatar_id
        self.save()

    def upload_avatar(self, img):
        avatar_id = generate_id()
        filename = UPLOAD_FOLDER / "avatars" / f"{avatar_id}.png"
        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:
            with open(filename, "wb") as f:
                img.save(f)
        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)

    @property
    def n_followers(self):
        return self._follow_stats[0]

    @property
    def n_following(self):
        return self._follow_stats[1]

    @property
    def _follow_stats(self):
        if self._stats is None:
            stats = userFollowStats.get(self.id)
            if not stats:
                self._stats = 0, 0
            else:
                self._stats = stats.follower_count, stats.following_count
        return self._stats