class Reply(db.Model):
__tablename__ = 'replies'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
# quote = db.Column(db.Text, nullable=True)
publish = db.Column(db.DateTime, default=datetime.now())
updated = db.Column(db.DateTime)
topic_id = db.Column(db.Integer,
db.ForeignKey('topics.id', ondelete="CASCADE"))
topic = db.relationship('Topic',
backref=db.backref(
'replies',
cascade='all,delete-orphan',
lazy='dynamic',
order_by='Reply.publish.desc()'))
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
author = db.relationship('User',
backref=db.backref('replies',
lazy='dynamic',
order_by='Reply.publish'))
likers = db.relationship('User',
secondary='likes',
backref=db.backref("likes", lazy='dynamic'))
__mapper_args__ = {"order_by": publish.desc()}
class Follow(db.Model):
__tablename__ = 'follows'
id = db.Column(db.Integer, primary_key=True)
follower_id = db.Column(db.Integer, db.ForeignKey('users.id'))
following_user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
following_tag_id = db.Column(db.Integer, db.ForeignKey('tags.id'))
following_collect_id = db.Column(db.Integer, db.ForeignKey('collects.id'))
followinf_topic_id = db.Column(db.Integer, db.ForeignKey('topics.id'))
class Blog(db.Model):
__tablename__ = 'blogs'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
created_at = db.Column(
db.DateTime, default=datetime.utcnow(), nullable=False)
updated_at = db.Column(
db.DateTime, default=datetime.utcnow(), onupdate=datetime.utcnow())
content = db.Column(db.Text, nullable=False)
is_copy = db.Column(db.Boolean, nullable=True, default=False)
category_id = db.Column(
db.Integer, db.ForeignKey(
'categories.id', ondelete="CASCADE"))
category = db.relationship(
'Category',
backref=db.backref(
'blogs', cascade='all,delete-orphan', lazy='dynamic'))
author_id = db.Column(
db.Integer, db.ForeignKey(
'users.id', ondelete="CASCADE"))
author = db.relationship(
'User',
backref=db.backref(
'blogs', cascade='all,delete-orphan', lazy='dynamic'))
__mapper_args__ = {"order_by": created_at.desc()}
def __repr__(self):
return "<Blog %r>" % self.title
def __str__(self):
return self.title
@classmethod
def get(cls, blogId):
return cls.query.filter_by(id=blogId).first_or_404()
@classmethod
def get_blog_list(cls, page=1, filter_dict=dict()):
per_page = current_app.config['PER_PAGE']
bloglist = cls.query
if 'tag' in filter_dict.keys():
tag = filter_dict.pop('tag')
bloglist = bloglist.join(cls.tags).filter(Tags.name == tag)
if 'category' in filter_dict.keys():
category = filter_dict.pop('category')
bloglist = bloglist.filter(cls.category == category)
bloglist = bloglist.paginate(page, per_page, True)
return bloglist
class Question(db.Model):
__tablename__ = 'questions'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(48), nullable=False)
describ = db.Column(db.Text, nullable=False)
answer = db.Column(db.Text, nullable=False)
is_private = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DateTime,
default=datetime.utcnow(),
nullable=False)
author_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
author = db.relationship('User',
backref=db.backref('questions',
cascade='all,delete-orphan',
lazy='dynamic'))
__mapper_args__ = {"order_by": created_at.desc()}
def __repr__(self):
return "<Question %r>" % self.title
def __str__(self):
return self.title
@classmethod
def get(cls, queId):
return cls.query.filter_by(id=queId).first_or_404()
@classmethod
def get_question_list(cls, page=1, filter_dict=dict()):
if not filter_dict:
return cls.query.paginate(page, 18, True)
return cls.query.filter_by(**filter_dict).paginate(page, 18, True)
class Topic(db.Model):
__tablename__ = 'topics'
id = db.Column(db.Integer, primary_key=True)
uid = db.Column(db.String(36), nullable=False)
title = db.Column(db.String(81), nullable=False)
content = db.Column(db.Text, nullable=False)
publish = db.Column(db.DateTime, default=datetime.utcnow())
updated = db.Column(db.DateTime)
vote = db.Column(db.Integer, default=0)
author_id = db.Column(db.Integer,
db.ForeignKey('users.id',
ondelete="CASCADE"))
author = db.relationship('User',
backref=db.backref('topics',
cascade='all,delete-orphan',
lazy='dynamic'))
board_id = db.Column(db.Integer,
db.ForeignKey('boards.id',
ondelete="CASCADE"))
board = db.relationship(
'Board',
backref=db.backref('topics',
cascade='all,delete-orphan',
lazy='dynamic',
order_by='Topic.publish.desc()'))
is_good = db.Column(db.Boolean, default=False)
is_top = db.Column(db.Boolean, default=False)
# is_top = db.Column(db.Integer, default = 0)
is_markdown = db.Column(db.Boolean, default=False)
is_draft = db.Column(db.Boolean, default=False)
__mapper_args__ = {"order_by": publish.desc()}
def __str__(self):
return self.title
def __repr__(self):
return "<Topic %r>" % self.title
def pagea(self, page=None):
per_page = current_app.config['PER_PAGE']
return self.paginate(page, per_page, True)
class Lover(db.Model):
__tablename__ = 'loves'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
reply_id = db.Column(db.Integer,
db.ForeignKey('replies.id', ondelete="CASCADE"))
like_time = db.Column(db.DateTime, default=datetime.now(), nullable=False)
def __init__(self):
self.like_time = datetime.now()
@staticmethod
def load_by_id(rid, uid):
return Lover.query.filter_by(reply_id=rid, user_id=uid).first()
@staticmethod
def load(rid, uid):
return Lover.query.filter_by(reply_id=rid, user_id=uid).first()
class Collector(db.Model):
__tablename__ = 'collects'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
question_id = db.Column(db.Integer,
db.ForeignKey('questions.id', ondelete="CASCADE"))
collect_time = db.Column(db.DateTime,
default=datetime.now(),
nullable=False)
def __init__(self):
self.collect_time = datetime.now()
@staticmethod
def load_by_id(qid, uid):
return Collector.query.filter_by(question_id=qid, user_id=uid).first()
@staticmethod
def load(qid, uid):
return Collector.query.filter_by(question_id=qid, user_id=uid).first()
class Replies(db.Model):
__tablename__ = 'replies'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
quote = db.Column(db.Text, nullable=True)
time = db.Column(db.DateTime, nullable=False)
question_id = db.Column(db.Integer,
db.ForeignKey('questions.id', ondelete="CASCADE"))
question = db.relationship('Questions',
backref=db.backref('replies',
cascade='all,delete-orphan',
lazy='dynamic',
order_by='Replies.time'))
lovers = db.relationship('User',
secondary='loves',
backref=db.backref('love_replies',
cascade='all,delete',
lazy='dynamic'))
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
author = db.relationship('User',
backref=db.backref('replies',
lazy='dynamic',
order_by='Replies.time'))
__mapper_args__ = {"order_by": time.desc()}
def __init__(self, content, quote):
self.content = content
self.quote = quote
self.time = datetime.now()
def __repr__(self):
return "<Replies %r>" % self.content
@staticmethod
def load_by_id(mode):
return Replies.query.filter_by(id=mode).first()
class Notice(db.Model):
__tablename__ = 'notices'
id = db.Column(db.Integer, primary_key=True)
publish = db.Column(db.DateTime, default=datetime.now())
category = db.Column(db.String(81), nullable=False)
content = db.Column(JSON)
is_read = db.Column(db.Boolean, default=False)
rece_id = db.Column(db.Integer, db.ForeignKey('users.id'))
rece_user = db.relationship("User",
backref="rece_user",
foreign_keys='Notice.rece_id',
uselist=False)
send_id = db.Column(db.Integer, db.ForeignKey('users.id'))
send_user = db.relationship("User",
backref="send_user",
foreign_keys='Notice.send_id',
uselist=False)
def __repr__(self):
return '<Notice %r>' % self.id
class Board_S(db.Model):
__tablename__ = 'board_s'
id = db.Column(db.Integer, primary_key=True)
chname_s = db.Column(db.String, nullable=False)
enname_s = db.Column(db.String, nullable=False)
board_id = db.Column(db.Integer, db.ForeignKey('board_f.id',
ondelete="CASCADE"))
board_f = db.relationship('Board_F',
backref=db.backref('board_s',
cascade='all,delete-orphan',
lazy='dynamic'))
count_id = db.Column(db.Integer,
db.ForeignKey('counts.id',
ondelete="CASCADE"))
count = db.relationship("Counts",
backref="board_s",
cascade='all,delete-orphan',
single_parent=True,
uselist=False)
__mapper_args__ = {
"order_by": enname_s
}
def __init__(self, chname_s, enname_s):
self.chname_s = chname_s
self.enname_s = enname_s
def __repr__(self):
return "<Board_S %r>" % self.id
@staticmethod
def load_by_name(name):
return Board_S.query.filter_by(enname_s=name).first_or_404()
@staticmethod
def load_by_id(bid):
return Board_S.query.filter_by(id=bid).first_or_404()
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(
db.DateTime, default=datetime.utcnow(), nullable=False)
content = db.Column(db.Text, nullable=False)
blog_id = db.Column(
db.Integer, db.ForeignKey(
'blogs.id', ondelete="CASCADE"))
blog = db.relationship(
'Blog',
backref=db.backref(
'comments', cascade='all,delete-orphan', lazy='dynamic'))
author_id = db.Column(
db.Integer, db.ForeignKey(
'users.id', ondelete="CASCADE"))
author = db.relationship(
'User',
backref=db.backref(
'comments', cascade='all,delete-orphan', lazy='dynamic'))
# def __init__(self, author, content):
# self.author = author
# self.content = content
def __repr__(self):
return "<Comment %r>" % self.content
@classmethod
def get_comment_list(cls, page=20, filter_dict=None):
per_page = current_app.config['PER_PAGE']
if filter_dict is None:
return cls.query.paginate(page, per_page, True)
commentlist = cls.query.filter_by(**filter_dict).paginate(
page, per_page, True)
return commentlist
class Comments(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
author = db.Column(db.String, nullable=False)
publish = db.Column(db.DateTime, nullable=False)
content = db.Column(db.Text, nullable=False)
articles_id = db.Column(db.Integer, db.ForeignKey('articles.id'))
article = db.relationship(
'Articles', backref=db.backref('comments', lazy='dynamic'))
def __init__(self, author, content):
self.author = author
self.content = content
def __repr__(self):
return "<Comments %r>" % self.content
class Permission(db.Model):
'''
admin_manager:admin_post,admin_edit,admin_read,admin_delete
que_manager:que_post,que_edit,que_read,que_delete
rep_manager:rep_post,rep_edit,rep_read,rep_delete
own_manager:update_password,update_infor,own_read
'''
__tablename__ = 'permission'
id = db.Column(db.Integer, primary_key=True)
percode = db.Column(db.String(81), nullable=False)
pername = db.Column(db.String(81), nullable=False)
description = db.Column(db.String(255), nullable=True)
module_id = db.Column(db.Integer,
db.ForeignKey('modules.id', ondelete="CASCADE"))
module = db.relationship('Module',
backref=db.backref('permission',
cascade='all,delete-orphan',
lazy='dynamic'))
roles = db.relationship('Role',
secondary='role_permission',
backref=db.backref('permission', lazy='dynamic'))
class UserInfor(db.Model):
__tablename__ = 'userinfor'
id = db.Column(db.Integer, primary_key=True)
confirmed_time = db.Column(db.DateTime, nullable=True)
registered_time = db.Column(db.DateTime, nullable=False)
score = db.Column(db.Integer, nullable=False, default=100)
word = db.Column(db.Text, nullable=True)
introduce = db.Column(db.Text, nullable=True)
school = db.Column(db.String, nullable=True)
count_id = db.Column(db.Integer,
db.ForeignKey('counts.id', ondelete="CASCADE"))
count = db.relationship("Counts",
backref="user",
cascade='all,delete-orphan',
single_parent=True,
uselist=False)
def __init__(self):
self.registered_time = datetime.now()
def __repr__(self):
return "<UserInfor %r>" % self.id
class Board_F(db.Model):
__tablename__ = 'board_f'
id = db.Column(db.Integer, primary_key=True)
chname_f = db.Column(db.String, nullable=False)
enname_f = db.Column(db.String, nullable=False)
rank = db.Column(db.Integer, nullable=False)
count_id = db.Column(db.Integer,
db.ForeignKey('counts.id',
ondelete="CASCADE"))
count = db.relationship("Counts",
backref="board_f",
cascade='all,delete-orphan',
single_parent=True,
uselist=False)
__mapper_args__ = {
"order_by": rank
}
def __init__(self, chname_f, enname_f,rank):
self.chname_f = chname_f
self.enname_f = enname_f
self.rank = rank
def __repr__(self):
return "<Board_F %r>" % self.id
@staticmethod
def load_all():
return Board_F.query.all()
@staticmethod
def load_by_id(bid):
return Board_F.query.filter_by(id=bid).first_or_404()
@staticmethod
def load_by_name(name):
return Board_F.query.filter_by(enname_f=name).first_or_404()
class Collect(db.Model):
__tablename__ = 'collects'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
description = db.Column(db.String(256))
is_privacy = db.Column(db.Boolean, default=False)
author_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
author = db.relationship('User',
backref=db.backref('collects',
cascade='all,delete-orphan',
lazy='dynamic'))
topics = db.relationship('Topic',
secondary='collect_topic',
lazy='dynamic',
backref="collects")
def __str__(self):
return self.name
def __repr__(self):
return "<Collect %r>" % self.name
class Board(db.Model):
__tablename__ = 'boards'
id = db.Column(db.Integer, primary_key=True)
rank = db.Column(db.Integer, default=1)
board = db.Column(db.String(81), nullable=False)
parent_board = db.Column(db.String(81), nullable=False)
description = db.Column(db.Text(), nullable=False)
count_id = db.Column(db.Integer,
db.ForeignKey('counts.id', ondelete="CASCADE"))
count = db.relationship('Count',
backref="board",
cascade='all,delete-orphan',
single_parent=True,
uselist=False)
__mapper_args__ = {"order_by": rank.desc()}
def __str__(self):
return self.board
def __repr__(self):
return '<Board %r>' % self.board
#!/usr/bin/env python # -*- coding: utf-8 -*- # ************************************************************************* # Copyright © 2015 JiangLin. All rights reserved. # File Name: models.py # Author:JiangLin # Mail:[email protected] # Created Time: 2015-11-08 06:42:40 # ************************************************************************* from flask import current_app from maple import db from datetime import datetime tag_blog = db.Table( 'tag_blog', db.Column('tags_id', db.Integer, db.ForeignKey('tags.id')), db.Column('blogs_id', db.Integer, db.ForeignKey('blogs.id'))) class Tags(db.Model): __tablename__ = 'tags' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) blogs = db.relationship( 'Blog', secondary=tag_blog, lazy='dynamic', backref="tags") def __repr__(self): return '<Tags %r>' % self.name def __str__(self): return self.name
class RolePermission(db.Model):
__tablename__ = 'role_permission'
id = db.Column(db.Integer, primary_key=True)
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
permission_id = db.Column(db.Integer, db.ForeignKey('permission.id'))
class Like(db.Model):
__tablename__ = 'likes'
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer, db.ForeignKey('users.id'))
reply_id = db.Column(db.Integer, db.ForeignKey('replies.id'))
like_time = db.Column(db.DateTime, default=datetime.now())
class CollectTopic(db.Model):
__tablename__ = 'collect_topic'
id = db.Column(db.Integer, primary_key=True)
topic_id = db.Column(db.Integer, db.ForeignKey('topics.id'))
collect_id = db.Column(db.Integer, db.ForeignKey('collects.id'))
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(49), unique=True)
email = db.Column(db.String(81), unique=True)
password = db.Column(db.String, nullable=False)
is_superuser = db.Column(db.Boolean, default=False)
is_confirmed = db.Column(db.Boolean, default=False)
register_time = db.Column(db.DateTime, default=datetime.now())
following_tags = db.relationship(
'Tags',
secondary='follows',
primaryjoin="User.id==follows.c.follower_id",
lazy='dynamic',
backref=db.backref('followers', lazy='dynamic'))
following_topics = db.relationship(
'Topic',
secondary='follows',
primaryjoin="User.id==follows.c.follower_id",
lazy='dynamic',
backref=db.backref('followers', lazy='dynamic'))
following_collects = db.relationship(
'Collect',
secondary='follows',
primaryjoin="User.id==follows.c.follower_id",
lazy='dynamic',
backref=db.backref('followers', lazy='dynamic'))
following_users = db.relationship(
'User',
secondary='follows',
primaryjoin="User.id==follows.c.follower_id",
secondaryjoin="User.id==follows.c.following_user_id",
lazy='dynamic',
backref=db.backref('followers', lazy='dynamic'),
)
setting_id = db.Column(db.Integer,
db.ForeignKey('usersetting.id', ondelete="CASCADE"))
setting = db.relationship("UserSetting",
backref="user",
cascade='all,delete',
uselist=False)
infor_id = db.Column(db.Integer,
db.ForeignKey('userinfor.id', ondelete="CASCADE"))
infor = db.relationship("UserInfor",
backref=db.backref('user', lazy='joined'),
cascade='all,delete',
uselist=False)
roles = db.relationship('Role',
secondary='user_role',
backref=db.backref('users'),
lazy='dynamic')
def __str__(self):
return self.username
def __repr__(self):
return '<User %r>' % self.username
# @property
# def password(self):
# return "密码不是可读形式!"
# @password.setter
# def password(self, password):
# self.password_hash = generate_password_hash(password)
# def verify_password(self, password):
# return check_password_hash(password)
@staticmethod
def set_password(password):
pw_hash = generate_password_hash(password)
return pw_hash
def check_password(self, password):
return check_password_hash(self.password, password)
class Questions(db.Model):
__tablename__ = 'questions'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.Text, nullable=False)
time = db.Column(db.DateTime, nullable=False)
kind = db.Column(db.String(60), nullable=True)
tags = db.relationship(
'Tags',
secondary=tag_question,
lazy='dynamic',
backref="questions",
cascade='all,delete-orphan',
single_parent=True,
# passive_deletes=True,
order_by='Tags.time.desc()')
is_good = db.Column(db.Boolean, nullable=False, default=False)
is_top = db.Column(db.Boolean, nullable=False, default=False)
is_markdown = db.Column(db.Boolean, nullable=False, default=False)
is_group = db.Column(db.Boolean, nullable=False, default=False)
last_author = db.Column(db.String, nullable=False)
last_time = db.Column(db.DateTime, nullable=False)
collectors = db.relationship('User',
secondary='collects',
backref=db.backref('collect_questions',
cascade='all,delete',
lazy='dynamic'))
author_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
author = db.relationship('User',
backref=db.backref('questions',
cascade='all,delete-orphan',
lazy='dynamic'))
group_id = db.Column(db.Integer,
db.ForeignKey('groups.id', ondelete="CASCADE"))
group = db.relationship('Group',
backref=db.backref('questions',
cascade='all,delete-orphan',
lazy='dynamic'))
board_id = db.Column(db.Integer,
db.ForeignKey('board_s.id', ondelete="CASCADE"))
board = db.relationship('Board_S',
backref=db.backref('questions',
cascade='all,delete-orphan',
lazy='dynamic'))
__mapper_args__ = {"order_by": time.desc()}
def __init__(self, title, content, kind):
self.title = title
self.content = content
self.kind = kind
self.time = datetime.now()
self.last_author = current_user.name
self.last_time = datetime.now()
def __repr__(self):
return "<Questions %r>" % self.title
@staticmethod
def load_by_id(mode):
return Questions.query.filter_by(id=mode).first_or_404()
@staticmethod
def load_by_kind(mode):
return Questions.query.filter_by(kind=mode).all()
# def verify_password(self, password):
# return check_password_hash(password)
@staticmethod
def set_password(password):
pw_hash = generate_password_hash(password)
return pw_hash
def check_password(self, password):
return check_password_hash(self.password, password)
roles_parents = db.Table(
'roles_parents', db.Column('role_id', db.Integer,
db.ForeignKey('roles.id')),
db.Column('parent_id', db.Integer, db.ForeignKey('roles.id')))
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(81), nullable=False, default='unconfirmed')
description = db.Column(db.String(255), nullable=True)
parents = db.relationship('Role',
secondary=roles_parents,
primaryjoin=(id == roles_parents.c.role_id),
secondaryjoin=(id == roles_parents.c.parent_id),
backref=db.backref('children'))
def __str__(self):
# Copyright © 2015 JiangLin. All rights reserved. # File Name: articledb.py # Author:JiangLin # Mail:[email protected] # Created Time: 2015-11-29 02:07:53 #************************************************************************* #!/usr/bin/env python # -*- coding=UTF-8 -*- from maple import db from datetime import datetime from flask_login import current_user tag_question = db.Table( 'tag_question', db.Column('tags_id', db.Integer, db.ForeignKey('tags.id', ondelete="CASCADE")), db.Column('questions_id', db.Integer, db.ForeignKey('questions.id', ondelete="CASCADE"))) class Tags(db.Model): __tablename__ = 'tags' '''帖子节点''' id = db.Column(db.Integer, primary_key=True) author = db.Column(db.String(50), nullable=False) name = db.Column(db.String(50), nullable=False) time = db.Column(db.DateTime, nullable=False) __mapper_args__ = {"order_by": time.desc()} def __init__(self, name, author):
class UserRole(db.Model):
__tablename__ = 'user_role'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
roles_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
#!/usr/bin/env python # -*- coding=UTF-8 -*- # ************************************************************************* # Copyright © 2015 JiangLin. All rights reserved. # File Name: models.py # Author:JiangLin # Mail:[email protected] # Created Time: 2015-11-08 06:42:40 # ************************************************************************* from maple import db from datetime import datetime tag_article = db.Table('tag_article', db.Column('tags_id', db.Integer, db.ForeignKey('tags.id')), db.Column('articles_id', db.Integer, db.ForeignKey('articles.id'))) class Tags(db.Model): __tablename__ = 'tags' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) def __repr__(self): return '<Tags %r>' % self.name @staticmethod def load_by_name(name): return Tags.query.filter_by(name=name).first_or_404()
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(
db.Integer,
primary_key=True,
)
name = db.Column(db.String, unique=True)
email = db.Column(db.String, unique=True)
passwd = db.Column(db.String, nullable=False)
# roles = db.Column(db.String, nullable=False, default='visitor')
is_superuser = db.Column(db.Boolean, default=False)
is_confirmed = db.Column(db.Boolean, nullable=False, default=False)
setting_id = db.Column(db.Integer,
db.ForeignKey('usersetting.id', ondelete="CASCADE"))
setting = db.relationship("UserSetting",
backref="users",
cascade='all,delete',
uselist=False)
infor_id = db.Column(db.Integer,
db.ForeignKey('userinfor.id', ondelete="CASCADE"))
infor = db.relationship("UserInfor",
backref="users",
cascade='all,delete',
uselist=False)
def __init__(self, name, email, passwd):
self.name = name
self.email = email
self.passwd = self.set_password(passwd)
def set_password(self, password):
self.pw_hash = generate_password_hash(password)
return self.pw_hash
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_auth_token(self):
from maple import login_serializer
data = [self.name, self.passwd]
return login_serializer.dumps(data)
def __repr__(self):
return "<User %r>" % self.name
@staticmethod
def load_by_id(uid):
user = User.query.filter_by(id=uid).first()
return user
@staticmethod
def load_by_name(name):
user = User.query.filter_by(name=name).first()
return user
@staticmethod
def load_by_email(email):
user = User.query.filter_by(email=email).first()
return user
@staticmethod
def check_password(user_password, password):
return check_password_hash(user_password, password)
# -*- coding=UTF-8 -*- # ************************************************************************** # Copyright © 2016 jianglin # File Name: models.py # Author: jianglin # Email: [email protected] # Created: 2016-07-20 17:00:08 (CST) # Last Update:星期四 2016-7-28 22:30:37 (CST) # By: # Description: # ************************************************************************** from maple import db from datetime import datetime tag_topic = db.Table( 'tag_topic', db.Column('tags_id', db.Integer, db.ForeignKey('tags.id')), db.Column('topics_id', db.Integer, db.ForeignKey('topics.id'))) tags_parents = db.Table( 'tags_parents', db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')), db.Column('parent_id', db.Integer, db.ForeignKey('tags.id'))) class Tags(db.Model): __tablename__ = 'tags' id = db.Column(db.Integer, primary_key=True) time = db.Column(db.DateTime, default=datetime.utcnow()) tagname = db.Column(db.String(64), nullable=False) summary = db.Column(db.Text) tags = db.relationship('Topic', secondary=tag_topic,
# Email: [email protected] # Created: 2016-07-24 15:10:52 (CST) # Last Update:星期日 2016-7-24 15:11:46 (CST) # By: # Description: # ************************************************************************** from maple import db from maple.tag.models import Tags from datetime import datetime from flask_login import UserMixin from werkzeug.security import (generate_password_hash, check_password_hash) from sqlalchemy import event roles_permissions = db.Table( 'roles_permissions', db.Column('role_id', db.Integer, db.ForeignKey('roles.id')), db.Column('permission_id', db.Integer, db.ForeignKey('permissions.id'))) routes_permissions = db.Table( 'routes_permissions', db.Column('route_id', db.Integer, db.ForeignKey('routes.id')), db.Column('permission_id', db.Integer, db.ForeignKey('permissions.id'))) class Route(db.Model): __tablename__ = 'routes' id = db.Column(db.Integer, primary_key=True) endpoint = db.Column(db.String(256), nullable=False) rule = db.Column(db.String(512), nullable=False) permissions = db.relationship('Permiss', secondary=routes_permissions,
