class Follow(db.Model):
__tablename__ = 'follows'
follower_id = db.Column(db.Integer,
db.ForeignKey('comments.id'),
primary_key=True)
followed_id = db.Column(db.Integer,
db.ForeignKey('comments.id'),
primary_key=True)
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 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 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 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
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 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 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)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
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 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 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 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 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 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 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)
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):
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)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', back_populates='articles')
#category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
#category = db.relationship('Category', back_populates='category')
#category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
#category = db.relationship('Category', back_populates='posts')
collectors = db.relationship('Collect',
back_populates='collected',
cascade='all')
comments = db.relationship('Comment',
back_populates='article',
cascade='all, delete-orphan')
tags = db.relationship('Tag', secondary=tagging, back_populates='articles')
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, index=True)
email = db.Column(db.String(254), unique=True, index=True)
password_hash = db.Column(db.String(128))
name = db.Column(db.String(30))
website = db.Column(db.String(255))
bio = db.Column(db.String(120))
location = db.Column(db.String(50))
member_since = db.Column(db.DateTime, default=datetime.utcnow)
locked = db.Column(db.Boolean, default=False)
active = db.Column(db.Boolean, default=True)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
role = db.relationship('Role', back_populates='users')
posts = db.relationship('Post', back_populates='author', cascade='all')
comments = db.relationship('Comment',
back_populates='author',
cascade='all')
# collections = db.relationship('Collect', back_populates='collector', cascade='all')
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.set_role()
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def set_role(self):
if self.role is None:
if self.email == current_app.config['BLOG_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 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 is_collecting(self, photo):
# return Collect.query.with_parent(self).filter_by(collected_id=photo.id).first() is not None
# def collect(self, post):
# if not self.is_collecting(post):
# collect = Collect(collector=self, collected=post)
# db.session.add(collect)
# db.session.commit()
def lock(self):
self.locked = True
self.role = Role.query.filter_by(name='Locked').first()
db.session.commit()
def unlock(self):
self.locked = False
self.role = Role.query.filter_by(name='User').first()
db.session.commit()
def block(self):
self.active = False
db.session.commit()
def unblock(self):
self.active = True
db.session.commit()
from datetime import datetime
from flask import current_app
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from blog.extensions import db
# from blog.extensions import whooshee
# relationship table
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 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 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
class PostReview(Text):
post_id = db.Column(db.ForeignKey('post.id'), nullable=False)
def user_id(self):
return db.Column('author', db.ForeignKey('user.id'), nullable=False)
import os
from flask import current_app
from datetime import datetime
from flask_avatars import Identicon
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from blog.extensions import db, whooshee
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 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 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
class ArticleReview(Text):
article_id = db.Column(db.ForeignKey('article.id'), nullable=False)
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
author_name = db.Column(db.String(64))
author_email = db.Column(db.String(64))
avatar_hash = db.Column(db.String(32))
article_id = db.Column(db.Integer, db.ForeignKey('articles.id'))
disabled = db.Column(db.Boolean, default=False)
comment_type = db.Column(db.String(64), default='comment')
reply_to = db.Column(db.String(128), default='notReply')
followed = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
backref=db.backref('follower', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
backref=db.backref('followed', lazy='joined'),
lazy='dynamic',
cascade='all, delete-orphan')
def __init__(self, **kwargs):
super(Comment, self).__init__(**kwargs)
if self.author_email is not None and self.avatar_hash is None:
self.avatar_hash = hashlib.md5(
self.author_email.encode('utf-8')).hexdigest()
def gravatar(self, size=40, default='identicon', rating='g'):
# if request.is_secure:
# url = 'https://secure.gravatar.com/avatar'
# else:
# url = 'http://www.gravatar.com/avatar'
url = 'http://gravatar.duoshuo.com/avatar'
hash = self.avatar_hash or hashlib.md5(
self.author_email.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
@staticmethod
def generate_fake(count=100):
from random import seed, randint
import forgery_py
seed()
article_count = Article.query.count()
for i in range(count):
a = Article.query.offset(randint(0, article_count - 1)).first()
c = Comment(content=forgery_py.lorem_ipsum.sentences(randint(3,
5)),
timestamp=forgery_py.date.date(True),
author_name=forgery_py.internet.user_name(True),
author_email=forgery_py.internet.email_address(),
article=a)
db.session.add(c)
try:
db.session.commit()
except:
db.session.rollback()
@staticmethod
def generate_fake_replies(count=100):
from random import seed, randint
import forgery_py
seed()
comment_count = Comment.query.count()
for i in range(count):
followed = Comment.query.offset(randint(0, comment_count -
1)).first()
c = Comment(content=forgery_py.lorem_ipsum.sentences(randint(3,
5)),
timestamp=forgery_py.date.date(True),
author_name=forgery_py.internet.user_name(True),
author_email=forgery_py.internet.email_address(),
article=followed.article,
comment_type='reply',
reply_to=followed.author_name)
f = Follow(follower=c, followed=followed)
db.session.add(f)
db.session.commit()
def is_reply(self):
if self.followed.count() == 0:
return False
else:
return True
# to confirm whether the comment is a reply or not
def followed_name(self):
if self.is_reply():
return self.followed.first().followed.author_name
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, index=True)
email = db.Column(db.String(254), unique=True, index=True)
password_hash = db.Column(db.String(128))
name = db.Column(db.String(30))
website = db.Column(db.String(255))
bio = db.Column(db.String(120))
location = db.Column(db.String(50))
member_since = db.Column(db.DateTime, default=datetime.utcnow)
avatar_s = db.Column(db.String(64))
avatar_m = db.Column(db.String(64))
avatar_l = db.Column(db.String(64))
avatar_raw = db.Column(db.String(64))
confirmed = db.Column(db.Boolean, default=False)
locked = db.Column(db.Boolean, default=False)
active = db.Column(db.Boolean, default=True)
public_collections = db.Column(db.Boolean, default=True)
receive_comment_notification = db.Column(db.Boolean, default=True)
receive_follow_notification = db.Column(db.Boolean, default=True)
receive_collect_notification = db.Column(db.Boolean, default=True)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
role = db.relationship('Role', back_populates='users')
#public_collections = db.Column(db.Boolean, default=True)
notifications = db.relationship('Notification',
back_populates='receiver',
cascade='all')
articles = db.relationship('Article',
back_populates='author',
cascade='all')
comments = db.relationship('Comment',
back_populates='author',
cascade='all')
#categories = db.relationship('Category', secondary=categorizing, back_populates='author')
collections = db.relationship('Collect',
back_populates='collector',
cascade='all')
following = db.relationship('Follow',
foreign_keys=[Follow.follower_id],
back_populates='follower',
lazy='dynamic',
cascade='all')
followers = db.relationship('Follow',
foreign_keys=[Follow.followed_id],
back_populates='followed',
lazy='dynamic',
cascade='all')
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.generate_avatar()
self.follow(self) # follow self
self.set_role()
def set_role(self):
if self.role is None:
if self.email == current_app.config['BLOG_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)
def validate_password(self, password):
return check_password_hash(self.password_hash, password)
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()
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 is_following(self, user):
if user.id is None: # when follow self, user.id will be None
return False
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
@property
def followed_photos(self):
return Article.query.join(
Follow, Follow.followed_id == Article.author_id).filter(
Follow.follower_id == self.id)
def collect(self, article):
if not self.is_collecting(article):
collect = Collect(collector=self, collected=article)
db.session.add(collect)
db.session.commit()
def uncollect(self, article):
collect = Collect.query.with_parent(self).filter_by(
collected_id=article.id).first()
if collect:
db.session.delete(collect)
db.session.commit()
def is_collecting(self, article):
return Collect.query.with_parent(self).filter_by(
collected_id=article.id).first() is not None
def lock(self):
self.locked = True
self.role = Role.query.filter_by(name='Locked').first()
db.session.commit()
def unlock(self):
self.locked = False
self.role = Role.query.filter_by(name='User').first()
db.session.commit()
def block(self):
self.active = False
db.session.commit()
def unblock(self):
self.active = True
db.session.commit()
@property
def is_admin(self):
return self.role.name == 'Administrator'
@property
def is_active(self):
return self.active
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
