class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
permissions = db.relationship('Permission',
secondary=roles_permissions,
back_populates='roles')
users = db.relationship('User', back_populates='role')
@staticmethod
def init_role():
roles_permissions_map = {
'Locked': ['FOLLOW', 'COLLECT'],
'User': ['FOLLOW', 'COLLECT', 'COMMENT', 'UPLOAD'],
'Moderator':
['FOLLOW', 'COLLECT', 'COMMENT', 'UPLOAD', 'MODERATE'],
'Administrator': [
'FOLLOW', 'COLLECT', 'COMMENT', 'UPLOAD', 'MODERATE',
'ADMINISTER'
]
}
for role_name in roles_permissions_map:
role = Role.query.filter_by(name=role_name).first()
if role is None:
role = Role(name=role_name)
db.session.add(role)
role.permissions = []
for permission_name in roles_permissions_map[role_name]:
permission = Permission.query.filter_by(
name=permission_name).first()
if permission is None:
permission = Permission(name=permission_name)
db.session.add(permission)
role.permissions.append(permission)
db.session.commit()
class Collect(db.Model):
collector_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
primary_key=True)
collected_id = db.Column(db.Integer,
db.ForeignKey('post.id'),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
collector = db.relationship('User',
back_populates='collections',
lazy='joined')
collected = db.relationship('Post',
back_populates='collectors',
lazy='joined')
class Follow(db.Model):
# follower 关注者
# followed 被关注者
# A 关注 B：A是follower，B是followed
follower_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
follower = db.relationship('User',
foreign_keys=[follower_id],
back_populates='following',
lazy='joined')
followed = db.relationship('User',
foreign_keys=[followed_id],
back_populates='followers',
lazy='joined')
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60))
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', back_populates='posts')
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
comments = db.relationship('Comment', back_populates='post', cascade='all')
collectors = db.relationship('Collect',
back_populates='collected',
cascade='all')
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', back_populates='comments')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', back_populates='comments')
replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
replied = db.relationship('Comment',
back_populates='replies',
remote_side=[id])
replies = db.relationship('Comment',
back_populates='replied',
cascade='all')
class Permission(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
roles = db.relationship('Role',
secondary=roles_permissions,
back_populates='permissions')
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
posts = db.relationship('Post', back_populates='category')
class User(db.Model, UserMixin):
# username 用户名，name 昵称
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(24), unique=True, index=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(254), unique=True, index=True)
name = db.Column(db.String(30), unique=True)
website = db.Column(db.String(255))
location = db.Column(db.String(50))
member_since = db.Column(db.DateTime, default=datetime.utcnow)
confirmed = db.Column(db.Boolean, default=False)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
role = db.relationship('Role', back_populates='users')
posts = db.relationship('Post', back_populates='user')
comments = db.relationship('Comment', back_populates='user')
collections = db.relationship('Collect',
back_populates='collector',
cascade='all')
following = db.relationship('Follow',
back_populates='follower',
foreign_keys=[Follow.follower_id],
lazy='dynamic',
cascade='all')
followers = db.relationship('Follow',
back_populates='followed',
foreign_keys=[Follow.followed_id],
lazy='dynamic',
cascade='all')
avatar_raw = db.Column(db.String(64))
avatar_s = db.Column(db.String(64))
avatar_m = db.Column(db.String(64))
avatar_l = db.Column(db.String(64))
__table_args__ = {'mysql_charset': 'utf8'}
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.set_role()
self.generate_avatar()
def set_role(self):
if self.role is None:
if self.email == current_app.config['ADMIN_EMAIL']:
self.role = Role.query.filter_by(name='Administrator').first()
else:
self.role = Role.query.filter_by(name='User').first()
db.session.commit()
def set_password(self, password):
self.password_hash = generate_password_hash(password=password)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
@property
def is_admin(self):
return self.role.name == 'Administrator'
def can(self, permission_name):
permission = Permission.query.filter_by(name=permission_name).first()
return permission is not None and self.role is not None and permission in self.role.permissions
def collect(self, post):
if not self.is_collecting(post):
collect = Collect(collector=self, collected=post)
db.session.add(collect)
db.session.commit()
def uncollect(self, post):
collect = Collect.query.with_parent(self).filter_by(
collected_id=post.id).first()
if collect:
db.session.delete(collect)
db.session.commit()
def is_collecting(self, post):
return Collect.query.with_parent(self).filter_by(
collected_id=post.id).first() is not None
def is_following(self, user):
return self.following.filter_by(
followed_id=user.id).first() is not None
def is_followed_by(self, user):
return self.followers.filter_by(
follower_id=user.id).first() is not None
def follow(self, user):
if not self.is_following(user):
follow = Follow(follower=self, followed=user)
db.session.add(follow)
db.session.commit()
def unfollow(self, user):
follow = self.following.filter_by(followed_id=user.id).first()
if follow:
db.session.delete(follow)
db.session.commit()
def generate_avatar(self):
avatar = Identicon()
filenames = avatar.generate(text=self.username)
self.avatar_s = filenames[0]
self.avatar_m = filenames[1]
self.avatar_l = filenames[2]
db.session.commit()
# Date :
# Description : 数据库模型
# Args :
# ===========================================================
from young.extensions import db
from flask_login import UserMixin
from flask import current_app
from werkzeug.security import (generate_password_hash, check_password_hash)
from datetime import datetime
from young.extensions import whooshee
from flask_avatars import Identicon
roles_permissions = db.Table(
'roles_permissions',
db.Column('role_id', db.Integer, db.ForeignKey('role.id')),
db.Column('permission_id', db.Integer, db.ForeignKey('permission.id')))
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
permissions = db.relationship('Permission',
secondary=roles_permissions,
back_populates='roles')
users = db.relationship('User', back_populates='role')
@staticmethod
def init_role():
roles_permissions_map = {
'Locked': ['FOLLOW', 'COLLECT'],