class Tag(db.Model):
__tablename__ = 'Tag'
tagId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
parentId = db.Column(db.BigInteger,
db.ForeignKey('Tag.tagId'),
nullable=True)
name = db.Column(db.Unicode(30), nullable=False)
description = db.Column(db.Text, nullable=False)
popularity = db.Column(db.Integer, default=0, nullable=False)
tagUsers = db.relationship('UserTag',
foreign_keys=[UserTag.userId],
backref=db.backref('users', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
articles = db.relationship('ArticleTag',
foreign_keys=[ArticleTag.articleId],
backref=db.backref('articles', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
problems = db.relationship('ProblemTag',
foreign_keys=[QuestionTag.questionId],
backref=db.backref('problems', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
class Menu(db.Model):
__tablename__ = 'menus'
id = db.Column(db.Integer, primary_key=True)
exclude_columns = ['created_at', 'updated_at']
auth_name = Column(db.String(32), nullable=False, index=True)
path = Column(db.String(256), nullable=False)
level = Column(db.Integer, nullable=True)
created_at = Column(db.Date, nullable=True, default=datetime.now)
updated_at = Column(db.Date, nullable=True, default=datetime.now)
parent_id = db.Column(db.Integer, db.ForeignKey('menus.id'))
children = db.relationship('Menu', back_populates='parent')
parent = db.relationship('Menu',
back_populates='children',
remote_side=[id])
# role_id = Column(db.Integer, db.ForeignKey('roles.id'))
# role = relationship('Role', backref=db.backref('menus', order_by=id))
# roles = relationship('Role', secondary=association_table, back_populates="menus")
# 将back_populates修改为db.backref() 指定 lazy = 'dynamic' 参数，关系两侧返回的查询都可接受额外的过滤器
roles = relationship('Role',
secondary=association_table,
backref=db.backref("menus", lazy='dynamic'))
def __init__(self, auth_name, path, **kwargs):
db.Model.__init__(self, auth_name=auth_name, path=path, **kwargs)
class Custom(db.Model):
__tablename__ = 'custom'
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True) # 客户的id
username = db.Column(db.String(30))
password = db.Column(db.String(30))
# CustomId = db.Column(db.String(30), unique=True)
CustomName = db.Column(db.String(30), default='无')
CustomPhone = db.Column(db.String(30), default='无')
CustomAddress = db.Column(db.String(100), default='无')
CustomAccount = db.Column(db.String(30), default='无')
CustomType = db.Column(db.String(30), default='无')
CustomConsume = db.Column(db.String(30), default=0)
orders = db.relationship('Order', backref='custom') # 一个顾客多个订单
serves = db.relationship('Serve', backref='custom')
def check_pwd(self, pwd):
if self.password == pwd:
return True
else:
return False
def __repr__(self):
return self.CustomConsume, self.CustomAccount
class Blog(db.Model):
__tablename__ = "blog"
id = db.Column(db.Integer, primary_key=True) # 编号
title = db.Column(db.String(255), unique=True) # 标题
text = db.Column(db.Text) # 内容
commentnum = db.Column(db.BigInteger, default=0) # 评论人数
add_time = db.Column(db.DateTime, index=True, default=datetime.now) # 写博客的时间
uid = db.Column(db.Integer, db.ForeignKey('user.id'))
comment = db.relationship('Comment', backref='blog')
blogcols = db.relationship('Blogcol', backref='blog')
class Project(db.Model):
__tablename__ = 'm_project'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255),nullable = True)
description = db.Column(db.String(255),nullable = True)
secretId = db.Column(db.String(255),nullable=True,unique=True)
createtime = db.Column(db.DateTime, default=datetime.now)
# manager_id = db.Column(db.Integer,db.ForeignKey('m_manager.id'))
entry = db.relationship('Entry', backref='m_project',uselist=False)
entryPendingAmount = db.Column(db.String(255),nullable=True)
language = db.relationship('Language',secondary='project_language',backref='m_project')
class Moviecol(db.Model):
__tablename__ = "moviecol"
id = db.Column(db.Integer, primary_key=True) # 编号
movie_id = db.Column(db.Integer, db.ForeignKey('movie.id')) # 所属视频
movie = db.relationship('Movie', backref='moviecols') # 视频收藏外键关系关联
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 所属用户
user = db.relationship('User', backref='moviecols') # 视频收藏外键关系关联
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
def __repr__(self):
return "<Moviecol %r>" % self.id
class Record(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
start = db.Column(db.DateTime)
finish = db.Column(db.DateTime)
remark = db.Column(db.String(120))
item_id = db.Column(db.Integer, db.ForeignKey('item.id'))
item = db.relationship('Item', back_populates='records')
tags = db.relationship('Tag',
secondary=record_tag,
back_populates='records')
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False)
username = db.Column(db.String(64), unique=True, index=True)
password = db.Column(db.Text)
role = db.Column(db.Integer, nullable=False)
posts = db.relationship('Post', backref='users')
trees = db.relationship('Tree', backref='users')
def __repr__(self):
return 'User:%s' % self.username
class Question(db.Model):
__tablename__ = 'Question'
questionId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userId = db.Column(db.BigInteger,
db.ForeignKey('User.id', ondelete='CASCADE'))
title = db.Column(db.Unicode(100), nullable=False)
content = db.Column(db.Text, nullable=False)
publicTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
answers = db.relationship('Answer',
backref=db.backref('answers'),
lazy='dynamic',
cascade='all, delete-orphan')
tags = db.relationship('QuestionTag',
backref=db.backref('tags'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteUsers = db.relationship('FavoriteQuestion',
backref=db.backref('favorite_users'),
lazy='dynamic',
cascade='all, delete-orphan')
@staticmethod
def generate_fake(count=100):
seed()
user_count = User.query.count()
for i in range(count):
user = User.query.offset(randint(0, user_count - 1)).first()
title = forgery_py.lorem_ipsum.sentence()
if len(title) > 50:
title = title[:20]
question = Question(userId=user.id,
title=title,
content=forgery_py.lorem_ipsum.sentences(
randint(1, 3)),
publicTime=forgery_py.date.date(True))
db.session.add(question)
try:
db.session.commit()
except:
db.session.rollback()
def get_user(self):
return User.query.filter(User.id == self.userId).first().username
def is_user_favorite(self, user):
return 'true' if self.questionId in map(
lambda x: x.questionId, user.favoriteQuestions.all()) else 'false'
def get_type(self):
return 'question'
class Item(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(10), unique=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='items')
records = db.relationship('Record',
back_populates='item',
cascade='all, delete-orphan')
@property
def recent_records(self):
return list(reversed(self.records[-5:]))
class Comment(db.Model):
__tablename__ = "comment"
id = db.Column(db.Integer, primary_key=True) # 编号
content = db.Column(db.Text) # 内容
movie_id = db.Column(db.Integer, db.ForeignKey('movie.id')) # 所属视频
movie = db.relationship('Movie', backref='comments') # 评论外键关系关联
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 所属用户
user = db.relationship('User', backref='comments') # 评论外键关系关联
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
def __repr__(self):
return "<Comment %r>" % self.id
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(10), unique=True)
items = db.relationship('Item',
back_populates='category',
cascade='all, delete-orphan')
class CourseFilter(db.Model):
__tablename__ = 'course_filter'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
positive = db.Column(db.Boolean)
user_id = db.Column(db.String(36), db.ForeignKey('user.id'))
course_ids = db.relationship('CourseIdentifier',
backref='filter',
lazy='dynamic')
def predicate(self, item):
# Check if the item matches the String course_id values, not the model objects
return (item in [course_id.id
for course_id in self.course_ids]) ^ self.positive
def apply(self, realm_ids):
for realm_id in realm_ids[:]:
if self.predicate(realm_id):
realm_ids.remove(realm_id)
def to_json(self):
return {
'id': self.id,
'positive': self.positive,
'course_ids': [id.to_json() for id in self.course_ids],
}
def __repr__(self):
return f'CourseFilter<{", ".join(str(course_id) for course_id in self.course_ids)}>'
class Edit(db.Model):
__tablename__ = 'edit'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.Text, nullable=False)
datetime = db.Column(db.DateTime, default=datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref=db.backref('edits'))
class User(db.Model):
__tablename__ = 'User'
userId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userName = db.Column(db.Unicode(20), nullable=False)
email = db.Column(db.Unicode(64), nullable=False)
phone = db.Column(db.CHAR(11), nullable=False)
password = db.Column(db.Unicode(100), nullable=False)
headImage = db.Column(db.Unicode(256), nullable=False)
permission = db.Column(db.CHAR(1), nullable=False)
introduction = db.Column(db.Text, default='这家伙很懒，什么也没有写~', nullable=False)
tags = db.relationship('UserTag',
foreign_keys=[UserTag.tagId],
backref=db.backref('tags'),
lazy='dynamic',
cascade='all, delete-orphan')
articles = db.relationship('Article', backref=db.backref('articles'))
questions = db.relationship('Question', backref=db.backref('questions'))
drafts = db.relationship('Draft', backref=db.backref('drafts'))
answers = db.relationship('Answer', backref=db.backref('answers'))
followed = db.relationship('Follow',
foreign_keys=[Follow.followerId],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followedId],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteArticles = db.relationship(
'FavoriteArticle',
foreign_keys=[FavoriteArticle.articleId],
backref=db.backref('articles', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteQuestions = db.relationship(
'FavoriteQuestion',
foreign_keys=[FavoriteQuestion.questionId],
backref=db.backref('questions', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
notifications = db.relationship('Notification',
backref=db.backref('notifications'))
class Admin(db.Model):
__tablename__ = "admin"
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(100), unique=True) # 管理员账号
pwd = db.Column(db.String(100)) # 管理员密码
is_super = db.Column(db.SmallInteger) # 是否为超级管理员，0为超级管理员
role_id = db.Column(db.Integer, db.ForeignKey('role.id')) # 所属角色
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
adminlogs = db.relationship("Adminlog", backref='admin') # 管理员登录日志外键关系关联
oplogs = db.relationship("Oplog", backref='admin') # 管理员操作日志外键关系关联
def __repr__(self):
return "<Admin %r>" % self.name
def check_pwd(self, pwd):
from werkzeug.security import check_password_hash
return check_password_hash(self.pwd, pwd)
class User(UserMixin, db.Model):
id = db.Column(db.String(36), primary_key=True)
username = db.Column(db.String(64))
email = db.Column(db.String(120))
timezone = db.Column(db.String(120))
profile_picture_url = db.Column(db.String(250))
ical_secret = db.Column(db.String(64), index=True, unique=True)
oauth_token = db.relationship('OAuth1Token', uselist=False, back_populates='user')
filters = db.relationship('CourseFilter', backref='user', lazy='dynamic')
colors = db.relationship('CourseColor', backref='user', lazy='dynamic')
alerts = db.relationship('EventAlert', backref='user', lazy='dynamic')
def apply_filters(self, realm_ids):
for filter in self.filters:
filter.apply(realm_ids)
def __repr__(self):
return '<User {}>'.format(self.username)
class Language(db.Model):
__tablename__ = 'm_language'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
description = db.Column(db.String(255), nullable=True)
name = db.Column(db.String(255), nullable=True)
shortName = db.Column(db.String(255), nullable=True)
createtime = db.Column(db.DateTime, default=datetime.now)
# manager_id = db.Column(db.Integer,db.ForeignKey('m_manager.id'))
entry = db.relationship('Entry', backref='m_language', uselist=False)
class Tag(db.Model):
__tablename__ = "tag"
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(80), unique=True) # 标题
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
movies = db.relationship("Movie", backref='tag') # 电影外键关系关联
def __repr__(self):
return "<Tag %r>" % self.name
class Question(db.Model):
__tablename__ = 'Question'
questionId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
title = db.Column(db.Unicode(100), nullable=False)
content = db.Column(db.Text, nullable=False)
publicTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
answers = db.relationship('Answer', backref=db.backref('answers'))
tags = db.relationship('QuestionTag',
foreign_keys=[QuestionTag.tagId],
backref=db.backref('tags', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
favoriteUsers = db.relationship('FavoriteQuestion',
foreign_keys=[FavoriteQuestion.userId],
lazy='dynamic',
cascade='all, delete-orphan')
class Role(db.Model):
__tablename__ = "role"
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(100), unique=True) # 名称
auths = db.Column(db.String(600)) # 角色权限列表
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
admins = db.relationship("Admin", backref='role') # 管理员外键关系关联
def __repr__(self):
return "<Role %r>" % self.name
class Manager(db.Model):
__tablename__ = 'm_manager'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
account = db.Column(db.String(255), nullable=True)
name = db.Column(db.String(255), nullable=True)
description = db.Column(db.String(255), nullable=True)
password = db.Column(db.String(255), nullable=True)
createtime = db.Column(db.DateTime, default=datetime.now)
parent_id = db.Column(db.Integer, nullable=True)
# permission = db.relationship('permission',backref='m_manager')
project = db.relationship('Project',
secondary='manager_project',
backref='m_manager')
permission = db.relationship('Permission',
secondary='manager_permission',
backref='m_manager')
language = db.relationship('Language',
secondary='manager_language',
backref=db.backref('m_manager', lazy='dynamic'))
class Userlog(db.Model):
__tablename__ = "userlog"
id = db.Column(db.Integer, primary_key=True) # 编号
user_id = db.Column(db.Integer, db.ForeignKey('user.id')) # 所属会员编号
user = db.relationship('User', backref='userlogs') # 会员日志外键关系关联
ip = db.Column(db.String(100)) # 登录IP
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 登录时间
def __repr__(self):
return "<Userlog %r>" % self.id
class Adminlog(db.Model):
__tablename__ = "adminlog"
id = db.Column(db.Integer, primary_key=True) # 编号
admin_id = db.Column(db.Integer, db.ForeignKey('admin.id')) # 所属管理员编号
admin = db.relationship('Admin', backref='adminlogs') #管理员登录日志外键关系关联
ip = db.Column(db.String(100)) # 登录IP
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 登录时间
def __repr__(self):
return "<Adminlog %r>" % self.id
class Answer(db.Model):
__tablename__ = 'Answer'
answerId = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True)
userId = db.Column(db.BigInteger,
db.ForeignKey('User.id', ondelete='CASCADE'),
nullable=False)
questionId = db.Column(db.BigInteger,
db.ForeignKey('Question.questionId',
ondelete='CASCADE'),
nullable=False)
content = db.Column(db.Text, nullable=False)
answerTime = db.Column(db.DateTime, default=datetime.now(), nullable=False)
answerComments = db.relationship('AnswerComment',
backref=db.backref('comments'),
lazy='dynamic',
cascade='all, delete-orphan')
likeUsers = db.relationship('LikeAnswer',
backref=db.backref('like_users'),
lazy='dynamic',
cascade='all, delete-orphan')
unlikeUsers = db.relationship('UnlikeAnswer',
backref=db.backref('unlike_users'),
lazy='dynamic',
cascade='all, delete-orphan')
def get_user(self):
return User.query.filter(User.id == self.userId).first().username
def get_question(self):
return Question.query.filter(
Question.questionId == self.questionId).first()
def is_user_like(self, user):
return 'true' if self.answerId in map(
lambda x: x.answerId, user.likeAnswers.all()) else 'false'
def is_user_unlike(self, user):
return 'true' if self.answerId in map(
lambda x: x.answerId, user.unlikeAnswers.all()) else 'false'
class Publisher(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), unique=True)
address = db.Column(db.String(20))
city = db.Column(db.String(20))
province = db.Column(db.String(20))
country = db.Column(db.String(30))
website = db.Column(db.String(30))
books = db.relationship('Book',
backref=db.backref('publishers'),
secondary=collection)
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(10), unique=True)
records = db.relationship('Record',
secondary=record_tag,
back_populates='tags')
@property
def recent_records(self):
return list(reversed(self.records[-5:]))
class Order(db.Model):
__tablename__ = 'order'
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
CustomId = db.Column(db.Integer, db.ForeignKey('custom.id'))
ProductId = db.Column(db.String(30))
OrderNum = db.Column(db.String(30))
OrderDate = db.Column(db.Date)
OrderStatus = db.Column(db.String(30))
OrderMoney = db.Column(db.String(30))
products = db.relationship('Product',
secondary=po,
backref=db.backref('order'))
sends = db.relationship('Send', backref='order', uselist=False)
def __repr__(self):
return self.OrderId, self.CustomId, self.ProductId, self.OrderNum, \
self.OrderDate, self.OrderStatus, self.OrderMoney
class Movie(db.Model):
__tablename__ = "movie"
id = db.Column(db.Integer, primary_key=True) # 编号
title = db.Column(db.String(255), unique=True) # 标题
url = db.Column(db.String(255), unique=True) # 地址
info = db.Column(db.Text) # 简介
logo = db.Column(db.String(255), unique=True) # 封面
star = db.Column(db.SmallInteger) # 星级
playnum = db.Column(db.BigInteger) # 播放量
commentnum = db.Column(db.BigInteger) # 评论量
tag_id = db.Column(db.Integer, db.ForeignKey('tag.id')) # 所属标签
area = db.Column(db.String(255)) # 上映地区
release_time = db.Column(db.Date) # 上映时间
length = db.Column(db.String(100)) # 播放时间
addtime = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
comments = db.relationship("Comment", backref='movie') # 评论外键关系关联
moviecols = db.relationship("Moviecol", backref='movie') # 收藏外键关系关联
def __repr__(self):
return "<Movie %r>" % self.title
class User(UserMixin, db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
username = db.Column(db.String(50), nullable=False, unique=True)
password_hash = db.Column(db.String(128))
email = db.Column(db.String(128), nullable=False, unique=True)
confirmed = db.Column(db.Boolean, default=False)
icon = db.Column(db.String(64), default='default.jpg')
# lazy 在这里是懒加载 dynamic表示不加载数据但是提供查询
# 如果一对一的关系 需要加上 uselist=Flase
posts = db.relationship("Posts", backref="user", lazy="dynamic")
# 当前用户通过 user 访问 posts 表中的字段
# 密码不能读 而且永不返回
@property
def password(self):
raise AttributeError("密码不可读的帅哥")
# 设置密码的时候 保存的是加密后的hash值
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
# 校验密码是否正确 正确 true 错误 false
# 先加密 再跟数据库比较
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
# 生成token 通过邮箱发送给用户
def generate_active_token(self, expires_in=3600):
s = Serializer(current_app.config['SECRET_KEY'], expires_in=expires_in)
return s.dumps({'id': self.id})
# 验证token 方法
@staticmethod
def check_active_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token)
except:
return False
# 这个id是从 token中解析出来的 然后根据id 到数据库中查找 对应的数据进行更新
u = User.query.get(data.get('id'))
if not u:
flash("该用户不存在")
return False
if not u.confirmed:
u.confirmed = True
db.session.add(u)
return True
