class Blog(db.Model, ModelUserMixin):
__tablename__ = 'blog'
CONTENT_TYPE_MARKDOWN = '0'
CONTENT_TYPE_ORGMODE = '1'
CONTENT_TYPE = (('0', 'markdown'), ('1', 'org-mode'))
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.Text, nullable=False)
content_type = db.Column(db.String(10),
nullable=False,
default=CONTENT_TYPE_MARKDOWN)
is_copy = db.Column(db.Boolean, nullable=True, default=False)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id', ondelete="CASCADE"),
nullable=False)
category = db.relationship('Category',
backref=db.backref('blogs',
cascade='all,delete-orphan',
lazy='dynamic'),
uselist=False,
lazy='joined')
# __mapper_args__ = {"order_by": Blog.created_at.desc()}
def __repr__(self):
return "<Blog %r>" % self.title
def __str__(self):
return self.title
def to_json(self):
return {
'id': self.id,
'title': self.title,
'category': self.category.name,
'tags': ','.join([tag.name for tag in self.tags]),
'author': self.author.username
}
def to_html(self):
length = current_app.config.get("SUMMARY_MAX_LENGTH")
if self.content_type == self.CONTENT_TYPE_MARKDOWN:
return markdown_to_html(self.content, length)
return orgmode_to_html(self.content, length)
@property
def read_times(self):
return Count.get('article:{}'.format(self.id))
@read_times.setter
def read_times(self, value):
Count.set('article:{}'.format(self.id))
class Images(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
path = db.Column(db.String(128), nullable=False, unique=True)
url = db.Column(db.String(360), unique=True)
def __repr__(self):
return "<Images %r>" % self.name
def __str__(self):
return self.name
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,
backref=db.backref('routes'))
def __str__(self):
return "<%s : %s>" % (self.endpoint, self.rule)
def __repr__(self):
return "<Route %r>" % self.endpoint
class Bucket(ModelUserMixin, db.Model):
__tablename__ = 'bucket'
name = db.Column(db.String(108), nullable=False, unique=True)
description = db.Column(db.String(1024), default='default')
def get_root_path(self, path, create=False):
filepath = self.rootpath
for name in path.split("/"):
if name == "":
continue
childpath = filepath.child_paths.filter_by(
name=name,
bucket_id=self.id,
).first()
if not childpath and not create:
return
if not childpath and create:
childpath = FilePath(
name=name,
bucket_id=self.id,
parent_id=filepath.id,
)
childpath.save()
filepath = childpath
return filepath
@property
def rootpath(self):
filepath = self.paths.filter_by(name="/").first()
if not filepath:
filepath = FilePath(name="/", bucket_id=self.id)
filepath.save()
return filepath
@property
def abspath(self):
return os.path.join(config.UPLOAD_FOLDER, self.name)
@property
def relpath(self):
return os.path.join(self.name)
def __repr__(self):
return '<Bucket %r>' % self.name
def __str__(self):
return self.name
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):
return self.name
def __repr__(self):
return '<Role %r>' % self.name
class Permiss(db.Model):
__tablename__ = 'permissions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(512), nullable=False)
is_allow = db.Column(db.Boolean, default=True)
method = db.Column(db.String(16), nullable=False)
roles = db.relationship('Role',
secondary=roles_permissions,
backref=db.backref('permissions'))
def __str__(self):
if self.is_allow:
return self.name + '允许' + self.method
else:
return self.name + '禁止' + self.method
def __repr__(self):
return "<Permiss %r>" % self.id
class UserSetting(db.Model):
'''
1:all user
2:logined user
3:only own
'''
__tablename__ = 'usersetting'
id = db.Column(db.Integer, primary_key=True)
online_status = db.Column(db.Integer, nullable=False, default=1)
topic_list = db.Column(db.Integer, nullable=False, default=1)
rep_list = db.Column(db.Integer, nullable=False, default=1)
ntb_list = db.Column(db.Integer, nullable=False, default=3)
collect_list = db.Column(db.Integer, nullable=False, default=2)
locale = db.Column(db.String(32), default='zh')
timezone = db.Column(db.String(32), default='UTC')
def __repr__(self):
return "<UserSetting %r>" % self.id
class Category(db.Model, ModelMixin):
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
def __repr__(self):
return '<Category %r>' % self.name
def __str__(self):
return self.name
class Tag(db.Model, ModelMixin):
__tablename__ = 'tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
blogs = db.relationship('Blog',
secondary=tag_blog,
backref=db.backref('tags', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return '<Tags %r>' % self.name
def __str__(self):
return 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
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 Question(db.Model, ModelUserMixin):
__tablename__ = 'question'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(48), nullable=False)
description = db.Column(db.Text, nullable=False)
answer = db.Column(db.Text, nullable=False)
is_hidden = db.Column(db.Boolean, default=False, nullable=False)
# __mapper_args__ = {"order_by": created_at.desc()}
def __repr__(self):
return "<Question %r>" % self.title
def __str__(self):
return self.title
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,
lazy='dynamic',
backref="tags")
parents = db.relationship('Tags',
secondary=tags_parents,
primaryjoin=(id == tags_parents.c.tag_id),
secondaryjoin=(id == tags_parents.c.parent_id),
backref=db.backref('children', lazy='joined'))
def __str__(self):
return self.tagname
def __repr__(self):
return '<Tags %r>' % self.tagname
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 Article(db.Model, ModelUserMixin):
__tablename__ = 'article'
CONTENT_TYPE_MARKDOWN = 0
CONTENT_TYPE_ORGMODE = 1
CONTENT_TYPE = ((0, 'markdown'), (1, 'org-mode'))
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50), nullable=False)
content = db.Column(db.Text, nullable=False)
content_type = db.Column(db.Integer,
nullable=False,
default=CONTENT_TYPE_MARKDOWN)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id', ondelete="CASCADE"),
nullable=False)
category = db.relationship('Category',
backref=db.backref('articles',
cascade='all,delete-orphan',
lazy='dynamic'),
uselist=False,
lazy='joined')
__mapper_args__ = {"order_by": text("created_at desc")}
def __repr__(self):
return "<Article %r>" % self.title
def __str__(self):
return self.title
def to_json(self):
return {
'id': self.id,
'title': self.title,
'category': self.category.name,
'tags': ','.join([tag.name for tag in self.tags]),
}
def to_html(self, length=None, truncate=False):
length = length or current_app.config.get("SUMMARY_MAX_LENGTH")
if not truncate:
length = None
if self.content_type == self.CONTENT_TYPE_MARKDOWN:
return markdown_to_html(self.content, length)
return orgmode_to_html(self.content, length)
@property
def htmlcontent(self):
return self.to_html()
@property
def next_article(self):
return Article.query.filter_by(id__lt=self.id).order_by("-id").first()
@property
def previous_article(self):
return Article.query.filter_by(id__gt=self.id).order_by("id").first()
@property
def read_times(self):
return Count.get('article:{}'.format(self.id))
@read_times.setter
def read_times(self, value):
Count.set('article:{}'.format(self.id))
class User(db.Model, UserMixin, ModelMixin):
__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 FilePath(ModelTimeMixin, db.Model):
__tablename__ = 'filepath'
name = db.Column(db.String(108), nullable=False, default="/")
bucket_id = db.Column(db.Integer,
db.ForeignKey('bucket.id', ondelete="CASCADE"),
nullable=False)
bucket = db.relationship(Bucket,
backref=db.backref(
'paths',
cascade='all,delete-orphan',
lazy='dynamic',
),
lazy='joined',
uselist=False)
parent_id = db.Column(
db.Integer,
db.ForeignKey('filepath.id', ondelete="CASCADE"),
)
@property
def size(self):
size = sum([
i[0]
for i in db.session.query(File.size).filter_by(path_id=self.id)
])
return size + sum([i.size for i in self.child_paths])
@declared_attr
def parent_path(cls):
return db.relationship('FilePath',
remote_side=[cls.id],
backref=db.backref('child_paths',
remote_side=[cls.parent_id],
cascade='all,delete-orphan',
lazy='dynamic'),
lazy='joined',
uselist=False)
@property
def abspath(self):
if self.is_root_path:
return self.bucket.abspath
return os.path.join(
self.parent_path.abspath,
self.name,
)
@property
def relpath(self):
if self.is_root_path:
return self.bucket.relpath
return os.path.join(
self.parent_path.relpath,
self.name,
)
@property
def fullname(self):
if self.is_root_path:
return "/"
return os.path.join(
self.parent_path.fullname,
self.name,
)
@property
def is_root_path(self):
return self.name == "/" and not self.parent_id
@property
def is_dir(self):
return True
def rename(self, newname):
newname = secure_filename(newname)
self.name = newname
self.save()
return self
def move(self, newpath):
filepath = newpath.child_paths.filter_by(name=self.name).first()
if not filepath:
self.parent_id = newpath.id
self.save()
return self
for fp in self.child_paths:
fp.move(filepath)
for f in self.files:
f.move(filepath)
self.delete()
return filepath
def copy(self, newpath):
# TODO: 性能优化
filepath = newpath.child_paths.filter_by(name=self.name).first()
if not filepath:
filepath = FilePath(
name=self.name,
bucket_id=self.bucket_id,
parent_id=newpath.id,
)
filepath.save()
for fp in self.child_paths:
fp.copy(filepath)
for f in self.files:
f.copy(filepath)
return filepath
def __str__(self):
if self.is_root_path:
return self.name
return os.path.join(
self.parent_path.__str__(),
self.name,
)
class File(ModelTimeMixin, db.Model):
__tablename__ = 'file'
FILE_TYPE = ("IMAGE", "CSS", "JS")
FILE_IMAGE = "IMAGE"
name = db.Column(db.String(108), nullable=False)
file_type = db.Column(db.String(108), nullable=False)
hash = db.Column(db.String(1024), nullable=False)
size = db.Column(db.Integer, nullable=False, default=0)
path_id = db.Column(db.Integer,
db.ForeignKey('filepath.id', ondelete="CASCADE"),
nullable=False)
path = db.relationship(FilePath,
backref=db.backref('files',
cascade='all,delete-orphan',
lazy='dynamic'),
lazy='joined',
uselist=False)
@property
def abspath(self):
return os.path.join(
self.path.abspath,
self.name,
)
@property
def relpath(self):
return os.path.join(
self.path.relpath,
self.name,
)
@property
def url(self):
args = dict(filename=self.relpath, _external=True)
if config.HTTPS:
args.update(**dict(_scheme="https"))
if self.file_type.startswith("image"):
args.update(type="mini")
return url_for("storage.show", **args)
@property
def is_dir(self):
return False
def save(self):
self.name = self.name.strip("/")
if "/" in self.name:
s = self.name.split("/")
filepath = FilePath.query.filter_by(id=self.path_id).first()
filepath = filepath.bucket.get_root_path("/".join(s[:-1]), True)
self.name = s[-1]
self.path_id = filepath.id
return super(File, self).save()
def copy(self, newpath):
f = File(
name=self.name,
file_type=self.file_type,
hash=self.hash,
path_id=newpath.id,
)
f.save()
return f
def move(self, newpath):
self.path_id = newpath
self.save()
return self
def rename(self, newname):
newname = secure_filename(newname)
self.name = newname
self.save()
return self
def __repr__(self):
return '<File %r>' % self.name
def __str__(self):
return self.name
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)
# @staticmethod
# def page(page):
# app = current_app._get_current_object()
# per_page = app.config['PER_PAGE']
# return Topic.paginate(page, per_page, True)
def to_json(self):
data = {
'id': self.id,
'uid': self.uid,
'title': self.uid,
'tags': self.tags,
'content': self.content,
'is_good': self.is_good,
'is_markdown': self.is_markdown,
'is_top': self.is_top,
'publish': self.publish,
'author': self.author.username
}
