class User(db.Model, UserMixin):
__tablename__ = 'user'
__table_args__ = ({'schema': 'public'})
id = db.Column('id', db.Integer, autoincrement=True, primary_key=True)
__password = db.Column('password', db.String)
username = db.Column(db.String(64), unique=True, nullable=False)
sex = db.Column(db.Boolean)
nickname = db.Column(db.String(10), unique=True)
_icon_path = db.Column('icon', db.String(20), unique=True)
signature = db.Column(db.String(25))
posts = db.relationship('Post', backref='user')
articles = db.relationship('Article', backref='user')
def __init__(self, username, password):
self.username = username
self.__password = generate_password_hash(password)
def __repr__(self):
return '<User %r>' % self.username
def check_password(self, pw):
return check_password_hash(self.__password, pw)
@property
def icon_path(self):
if self._icon_path is None:
return '/static/no-icon.jpg'
else:
return os.path.join('/static/uploads/icons', self._icon_path)
class Role(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
users = db.relationship('User', back_populates='role')
permissions = db.relationship('Permission',
secondary=roles_permissions,
back_populates='roles')
@staticmethod
def init_role():
roles_permissions_map = {
'Locked': ['COLLECT'],
'User': ['POST', 'COLLECT', 'COMMENT'],
'Moderator': ['POST', 'COLLECT', 'COMMENT', 'MODERATE'],
'Administrator':
['POST', 'COLLECT', 'COMMENT', '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 Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), nullable=False)
author = db.Column(db.String(20), nullable=False)
content = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship("Category", back_populates="posts")
comment = db.relationship('Comment', back_populates='post')
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)
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') #设置级联删除
class Answer(db.Model):
__tablename__ = 'answer'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
answer_time = db.Column(db.DateTime, default=datetime.now)
question_id = db.Column(db.Integer, db.ForeignKey('question.id'))
answer_id = db.Column(db.Integer, db.ForeignKey('user.id'))
answer_name = db.relationship('User', backref=db.backref('answers'))
question = db.relationship('Question', backref=db.backref('answers',
order_by=id.desc()))
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
reply = db.Column(db.Text) #如果超出？
author = db.Column(db.String(30))
time = db.Column(db.DateTime, default=datetime.utcnow)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
post = db.relationship('Post', back_populates='comment')
replies = db.relationship('Comment',
back_populates='replied',
cascade='all')
replied = db.relationship('Comment', back_populates='replies')
class Article(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
body = db.Column(db.Text)
category = db.relationship('Category', back_populates='articles')
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
comment_open = db.Column(db.Boolean, default=True)
count_read = db.Column(db.Integer)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
comments = db.relationship('Comment',
back_populates='article',
cascade='all, delete-orphan')
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text)
author = db.Column(db.String(30))
email = db.Column(db.String(254))
reviewed = db.Column(db.Boolean, default=False)
from_admin = db.Column(db.Boolean, default=False)
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')
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 Collect(db.Model):
collector_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
primary_key=True)
collected_id = db.Column(db.Integer,
db.ForeignKey('article.id'),
primary_key=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
collector = db.relationship('User',
back_populates='collections',
lazy='joined')
collected = db.relationship('Article',
back_populates='collectors',
lazy='joined')
class Article(Text):
title = db.Column(db.String(50), nullable=False)
like = db.Column(db.Integer, default=0, nullable=False)
reviews = db.relationship('ArticleReview', backref='article')
def __repr__(self):
return '<Article %r>' % self.id
class ArticleTypeSetting(db.Model):
__tablename__ = 'articleTypeSettings'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
protected = db.Column(db.Boolean, default=False)
hide = db.Column(db.Boolean, default=False)
types = db.relationship('ArticleType', backref='setting', lazy='dynamic')
@staticmethod
def insert_system_setting():
system = ArticleTypeSetting(name='system', protected=True, hide=True)
db.session.add(system)
db.session.commit()
@staticmethod
def insert_default_settings():
system_setting = ArticleTypeSetting(name='system',
protected=True,
hide=True)
common_setting = ArticleTypeSetting(name='common',
protected=False,
hide=False)
db.session.add(system_setting)
db.session.add(common_setting)
db.session.commit()
@staticmethod
def return_setting_hide():
return [(2, u'公开'), (1, u'隐藏')]
def __repr__(self):
return '<ArticleTypeSetting %r>' % self.name
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), index=True, unique=True)
articles = db.relationship('Article',
secondary=tagging,
back_populates='tags')
class Menu(db.Model):
__tablename__ = 'menus'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
types = db.relationship('ArticleType', backref='menu', lazy='dynamic')
order = db.Column(db.Integer, default=0, nullable=False)
def sort_delete(self):
for menu in Menu.query.order_by(Menu.order).offset(self.order).all():
menu.order -= 1
db.session.add(menu)
@staticmethod
def insert_menus():
menus = [u'Web开发', u'数据库', u'网络技术', u'爱生活，爱自己', u'Linux世界', u'开发语言']
for name in menus:
menu = Menu(name=name)
db.session.add(menu)
db.session.commit()
menu.order = menu.id
db.session.add(menu)
db.session.commit()
@staticmethod
def return_menus():
menus = [(m.id, m.name) for m in Menu.query.all()]
menus.append((-1, u'不选择导航（该分类将单独成一导航）'))
return menus
def __repr__(self):
return '<Menu %r>' % self.name
class Book(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
comment = db.Column(db.TEXT)
category_id = db.Column(db.Integer, db.ForeignKey('book_category.id'))
category = db.relationship('BookCategory', back_populates='books')
class Follow(db.Model):
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 Link(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(60))
url = db.Column(db.String(200), unique=True)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
category_id = db.Column(db.Integer, db.ForeignKey('link_category.id'))
category = db.relationship('LinkCategory', back_populates='links')
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, index=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
class Blog(db.Model):
__tablename__ = 'blog'
id = db.Column(db.Integer, primary_key=True)
blog_title = db.Column(db.String(128), nullable=False)
blog_content = db.Column(db.Text)
create_time = db.Column(db.DateTime, default=datetime.now)
blogger_id = db.Column(db.Integer, db.ForeignKey('user.id'))
blogger = db.relationship('User', backref=db.backref('blogs'))
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, index=True)
can_comment = db.Column(db.Boolean, default=True)
flag = db.Column(db.Integer, default=0)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = 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, delete-orphan')
class Question(db.Model):
__tablename__ = 'question'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
content = db.Column(db.Text, nullable=False)
ques_time = db.Column(db.DateTime, default=datetime.now)
blogger_id = db.Column(db.Integer, db.ForeignKey('user.id'))
blogger = db.relationship('User', backref=db.backref('questions'))
class Notification(db.Model):
id = db.Column(db.Integer, primary_key=True)
message = db.Column(db.Text, nullable=False)
is_read = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
receiver_id = db.Column(db.Integer, db.ForeignKey('user.id'))
receiver = db.relationship('User', back_populates='notifications')
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)
#flag = db.Column(db.Integer, default=0)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', back_populates='comments')
article_id = db.Column(db.Integer, db.ForeignKey('article.id'))
article = db.relationship('Article', back_populates='comments')
replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
replies = db.relationship('Comment',
back_populates='replied',
cascade='all')
replied = db.relationship('Comment',
back_populates='replies',
remote_side=[id])
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
person_post = db.Column(db.String(30))
body = db.Column(db.Text)
from_admin = db.Column(db.Boolean, default=False)
reviewed = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
email = db.Column(db.String(255))
site = db.Column(db.String(255))
reply_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
article_id = db.Column(db.Integer, db.ForeignKey('article.id'))
# to support comments to reply comments
article = db.relationship('Article', back_populates='comments')
replies = db.relationship('Comment',
back_populates='replied',
cascade='all, delete-orphan')
replied = db.relationship('Comment',
back_populates='replies',
remote_side=[id])
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), unique=True)
articles = db.relationship('Article', back_populates='category')
def delete(self):
default = Category.query.get(1)
articles = self.articles[:]
for a in articles:
a.category = default
db.session.delete(self)
db.session.commit()
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')
def delete(self):
default_category = Category.query.get(1)
posts = self.posts[:]
for post in posts:
post.category = default_category
db.session.delete(self)
db.session.commit()
class ArticleType(db.Model):
__tablename__ = 'articleTypes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
introduction = db.Column(db.Text, default=None)
articles = db.relationship('Article',
backref='articleType',
lazy='dynamic')
menu_id = db.Column(db.Integer, db.ForeignKey('menus.id'), default=None)
setting_id = db.Column(db.Integer, db.ForeignKey('articleTypeSettings.id'))
@staticmethod
def insert_system_articleType():
articleType = ArticleType(
name=u'未分类',
introduction=u'系统默认分类，不可删除。',
setting=ArticleTypeSetting.query.filter_by(protected=True).first())
db.session.add(articleType)
db.session.commit()
@staticmethod
def insert_articleTypes():
articleTypes = [
'Python', 'Java', 'JavaScript', 'Django', 'CentOS', 'Ubuntu',
'MySQL', 'Redis', u'Linux成长之路', u'Linux运维实战', u'其它', u'思科网络技术',
u'生活那些事', u'工作那些事', u'感情那些事', 'Flask'
]
for name in articleTypes:
articleType = ArticleType(name=name,
setting=ArticleTypeSetting(name=name))
db.session.add(articleType)
db.session.commit()
@property
def is_protected(self):
if self.setting:
return self.setting.protected
else:
return False
@property
def is_hide(self):
if self.setting:
return self.setting.hide
else:
return False
# if the articleType does not have setting,
# its is_hie and is_protected property will be False.
def __repr__(self):
return '<Type %r>' % self.name
class BookCategory(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True)
books = db.relationship('Book', back_populates='category')
def delete(self):
default_category = BookCategory.query.get(1)
books = self.books[:]
for book in books:
book.category = default_category
db.session.delete(self)
db.session.commit()
class LinkCategory(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), unique=True)
links = db.relationship('Link', back_populates='category')
def delete(self):
default_category = LinkCategory.query.get(1)
links = self.links[:]
for link in links:
link.category = default_category
db.session.delete(self)
db.session.commit()
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String(30))
email = db.Column(db.String(254))
site = db.Column(db.String(255))
body = db.Column(db.Text)
from_admin = db.Column(db.Boolean, default=False)
reviewed = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)
# 在评论内建立评论和回复的一对多关系，需要在内部添加一个外键指向它自身
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
post = db.relationship('Post', back_populates='comments')
#all,delete-orphan注意用逗号隔开
replies = db.relationship('Comment',
back_populates='replied',
cascade='all, delete-orphan')
replied = db.relationship('Comment',
back_populates='replies',
remote_side=[id])
class Article(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64), unique=True)
thumbnail = db.Column(db.String(255), default='')
content = db.Column(db.Text)
summary = db.Column(db.Text)
create_time = db.Column(db.DateTime, index=True, default=datetime.utcnow)
update_time = db.Column(db.DateTime, index=True, default=datetime.utcnow)
num_of_view = db.Column(db.Integer, default=0)
articleType_id = db.Column(db.Integer, db.ForeignKey('articleTypes.id'))
source_id = db.Column(db.Integer, db.ForeignKey('sources.id'))
comments = db.relationship('Comment', backref='article', lazy='dynamic')
@staticmethod
def generate_fake(count=100):
from sqlalchemy.exc import IntegrityError
from random import seed, randint
import forgery_py
seed()
articleType_count = ArticleType.query.count()
source_count = Source.query.count()
for i in range(count):
aT = ArticleType.query.offset(randint(0, articleType_count -
1)).first()
s = Source.query.offset(randint(0, source_count - 1)).first()
a = Article(title=forgery_py.lorem_ipsum.title(randint(3, 5)),
content=forgery_py.lorem_ipsum.sentences(
randint(15, 35)),
summary=forgery_py.lorem_ipsum.sentences(randint(2,
5)),
num_of_view=randint(100, 15000),
articleType=aT,
source=s)
db.session.add(a)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
@staticmethod
def add_view(article, db):
article.num_of_view += 1
db.session.add(article)
db.session.commit()
def __repr__(self):
return '<Article %r>' % self.title
