class Permission(BaseModel, db.Model):
"""
desc: 权限表
"""
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
target = db.Column(db.String(20))
target_desc = db.Column(db.String(50))
permission = db.Column(db.String(10))
permission_desc = db.Column(db.String(50))
def __init__(self, target, target_desc, permission, permission_desc):
self.target = target
self.target_desc = target_desc
self.permission = permission
self.permission_desc = permission_desc
def __eq__(self, other):
if other.target == self.target and other.target_desc == self.target_desc \
and other.permission == self.permission and other.permission_desc == self.permission_desc:
return True
else:
return False
def to_dict(self):
return self._to_dict(target=self.target,
target_desc=self.target_desc,
permission=self.permission,
premission_desc=self.permission_desc)
class Animals(db.Model):
id = db.Column(db.Integer, primary_key=True)
animal = db.Column(db.String(30))
noise = db.Column(db.String(30))
def __repr__(self):
return ''.join(['Animals:', self.animal, 'Noise:', self.noise])
class Contact(db.Model):
__tablename__ = "contacts"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(100), nullable=False)
phone = db.Column(db.String(20), nullable=False)
content = db.Column(db.Text(), nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow())
def __str__(self):
return self.name
class Photo(db.Model):
__tablename__ = 'photo'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
ext = db.Column(db.String(10))
content = db.Column(db.LargeBinary) # store the image into db
path = db.Column(db.String(255)) # image url or file path for the image.
type = db.Column(db.String(100)) # list of type, split with comma
def __repr__(self):
return '<Photo %r>' % self.name
class EBook(db.Model):
__tablename__ = 'ebook'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
mediatype = db.Column(
db.String(100)) # with the media type id, split with comma
storage = db.Column(db.Integer)
file_path = db.Column(db.String(500))
actors = db.Column(db.String(100)) # The list of author.
def __repr__(self):
return '<EBook %r>' % self.name
class Actor(db.Model):
__tablename__ = 'actor'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
sex = db.Column(db.Integer) # 0 is male, 1 is female.
country = db.Column(db.String(50))
description = db.Column(db.Text)
thumb = db.Column(db.Integer) # the record id in photo table.
type = db.Column(db.String(100)) # the mediatype list for the actor.
def __repr__(self):
return '<Actor %r>' % self.name
class Role(TimeStamp, db.Model, SerializerMixin):
__tablename__ = 'role'
serialize_only = ('role_name', 'description', 'id', 'is_active')
id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(150), nullable=True)
description = db.Column(db.Text, nullable=True)
is_active = db.Column(db.SmallInteger, default=1)
users = db.relationship("User",
secondary="user_roles",
back_populates="roles")
def __repr__(self):
return '<Role %r>' % (self.role_name)
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def to_json(self):
return {
'role_name': self.role_name,
'description': self.description,
'id': self.id,
'is_active': self.is_active
}
class User(TimeStamp, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True, nullable=False)
first_name = db.Column(db.String(255), unique=False, nullable=True)
last_name = db.Column(db.String(255), unique=False, nullable=True)
password = db.Column(db.Text, unique=False, nullable=False)
user_type = db.Column(db.SmallInteger, default=1)
access_token = db.Column(db.Text, nullable=True)
roles = db.relationship("Role",
secondary="user_roles",
back_populates="users")
def save_to_db(self):
db.session.add(self)
db.session.commit()
def to_json(self):
return {
'first_name': self.first_name,
'last_name': self.last_name,
'email': self.email,
'id': self.id,
'access_token': self.access_token,
'user_type': self.user_type
}
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_id(cls, id):
return cls.query.filter_by(id=id).first()
@staticmethod
def generate_hash(password):
return sha256.hash(password)
@staticmethod
def verify_hash(password, hash):
return sha256.verify(password, hash)
def __repr__(self):
return '<User %r>' % (self.first_name)
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True)
password = db.Column(db.String(50))
create_at = db.Column(db.DateTime, default=datetime.datetime.now())
update_at = db.Column(db.DateTime, default=datetime.datetime.now())
def __repr__(self):
return '<User %r>' % self.username
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
class MediaType(db.Model):
__tablename__ = 'mediatype'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
parent = db.Column(db.Integer)
def __repr__(self):
return '<MediaType %r>' % self.name
class Storage(db.Model):
__tablename__ = 'storage'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
mediatype = db.Column(db.Integer)
size = db.Column(db.Float)
def __repr__(self):
return '<Storage %r>' % self.name
class Prizes(db.Model):
id = db.Column(db.Integer, primary_key=True)
prize_value = db.Column(db.Integer)
no_of_balls = db.Column(db.Integer)
lightening_ball = db.Column(db.String(3))
def __repr__(self):
return ''.join([
'Prize:', self.prize_value, 'Number of Balls:', self.no_of_balls,
'Lightening Ball:', self.lightening_ball
])
class User(db.Model):
"""
用户信息表
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(16))
password = db.Column(db.String(100))
create_time = db.Column(db.DateTime, default=datetime.datetime.now)
# 多对多的双向关联，用于跨表查询
roles = db.relationship('Role', secondary=user_role, passive_deletes=True)
def check_password(self, password):
from werkzeug.security import check_password_hash
return check_password_hash(self.password, password)
def __str__(self):
return '<User %s>' % self.username
class Permission(db.Model):
"""
权限表
"""
__tablename__ = 'permission'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(10))
url = db.Column(db.String(64))
menu_ref = db.Column(db.Integer, db.ForeignKey('permission.id')) # 自关联
code = db.Column(db.String(10))
group_id = db.Column(db.Integer, db.ForeignKey('permissiongroup.id'))
# 自关联声明
self_ref = db.relationship('Permission', remote_side=[id])
# 多对多的双向关联，用于跨表查询
roles = db.relationship('Role', secondary=permission_role, passive_deletes=True)
def __str__(self):
return '<Permission> %s' % self.title
class Students(BaseModel, db.Model):
"""
desc: 学生表模型
"""
name = db.Column(db.String(20))
def __init__(self, name):
self.name = name
def to_dict(self):
return self._to_dict(name=self.name)
class Menu(db.Model):
"""
菜单表
"""
__tablename__ = 'menu'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(10))
# 双向关联，用于跨表查询
perm_groups = db.relationship('PermissionGroup', backref='menu')
def __str__(self):
return '<Menu %s>' % self.title
class Role(db.Model):
"""
角色表
"""
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(10))
# 多对多的双向关联，用于跨表查询
permissions = db.relationship('Permission', secondary=permission_role, passive_deletes=True)
users = db.relationship('User', secondary=user_role, passive_deletes=True)
def __str__(self):
return '<Role %s>' % self.name
class PermissionGroup(db.Model):
"""
权限组表
"""
__tablename__ = 'permissiongroup'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(10))
menu_id = db.Column(db.Integer, db.ForeignKey('menu.id'))
# 双向关联，用于跨表查询
permissions = db.relationship('Permission', backref='perm_group')
def __str__(self):
return '<PermissionGroup %s>' % self.title
class Role(BaseModel, db.Model):
"""
desc: 角色表
"""
name = db.Column(db.String(20))
comment = db.Column(db.String(100))
def __init__(self, name, comment):
self.name = name
self.create_date = datetime.datetime.now()
self.modify_date = datetime.datetime.now()
self.comment = comment
def to_dict(self):
return self._to_dict(name=self.name, comment=self.comment)
def update(self, **kwargs):
"""
desc: 更新角色信息
"""
self.name = kwargs['name']
self.comment = kwargs['comment']
class Movie(db.Model):
__tablename__ = 'movie'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
actors = db.Column(db.String(100)) # with the actor id list: 1,2,3
cover = db.Column(db.Integer) # withe the photo id, type is Cover
snapshots = db.Column(db.String(100)) # with the photo id list: 1,2,3
types = db.Column(db.String(100)) # with the media type id list: 1,2,3
provider = db.Column(db.String(100)) # the provider of the movie
storage = db.Column(db.Integer) # with the storage id
file_path = db.Column(db.String(500)) # file path on storage
def __repr__(self):
return '<Movie %r>' % self.name
class Todos(db.Model):
id = db.Column(db.Integer, primary_key=True)
task = db.Column(db.String(30), unique=True)
complete = db.Column(db.Boolean, default=False)
class User(BaseModel, db.Model):
username = db.Column(db.String(20), unique=True)
nickname = db.Column(db.String(30))
password = db.Column(db.String(32))
email = db.Column(db.String(255), default="")
is_superuser = db.Column(db.Boolean, default=False)
def __init__(self,
username,
nickname,
password,
email,
create_date=None,
modify_date=None,
is_superuser=False):
self.username = username
self.nickname = nickname if nickname else username
self.create_date = create_date if create_date else datetime.datetime.now(
)
self.modify_date = modify_date if modify_date else datetime.datetime.now(
)
self.password = self._hash_password(password)
self.email = email
self.is_superuser = is_superuser
def _hash_password(self, password):
key = "%s%s" % (password, 'SECRET')
return hashlib.md5(key).hexdigest()
def verify_password(self, password):
return self.password == self._hash_password(password)
def update_password(self, password):
self.password = self._hash_password(password)
def update(self, **kwargs):
self.username = kwargs['username']
if kwargs.get("email"):
self.email = kwargs["email"]
if kwargs.get("nickname"):
self.nickname = kwargs["nickname"]
def to_dict(self):
return self._to_dict(username=self.username,
nickname=self.nickname,
email=self.email)
def generate_auth_token(self):
"""
desc: 生成登录用户的token
params: user_id 用户唯一标识号
return: token
date: 2016-10-28
"""
s = TimedJSONWebSignatureSerializer(
current_app.config.get("SECRET_KEY", "No secret key"),
current_app.config.get("USER_TOKEN_EXPIRATION", 3600))
return s.dumps({"user_id": self.id})
@classmethod
def verify_auth_token(cls, token):
s = TimedJSONWebSignatureSerializer(
current_app.config.get("SECRET_KEY", "No secret key"))
try:
data = s.loads(token)
except SignatureExpired:
raise TokenExpired(
http_responses.HTTP_400_BAD_REQUEST(
msg={"error": u"Token过期了，请重新登录"}))
except BadSignature:
raise BadToken(
http_responses.HTTP_400_BAD_REQUEST(
msg={"error": u"Token无效，请重新登录"}))
try:
user = User.get_object(id=data["user_id"])
except ObjectNotExists:
raise BadToken(
http_responses.HTTP_400_BAD_REQUEST(
msg={"error": u"Token无效，请重新登录"}))
return user
