class User(BaseModel, UserMixin):
__tablename__ = 'users'
email = db.Column(db.String(length=100))
name = db.Column(db.String(length=100), unique=True)
password = db.Column(db.Text)
active = db.Column(db.Boolean, default=True)
class Admin(db.Model):
__tablename__ = 'admin'
id = db.Column(db.Integer, primary_key=True)
adminName = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
logs = db.relationship('AdminLog', backref='admin')
def __repr__(self):
return "<Admin %r>" % self.adminName
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
userAvatar = db.Column(db.String(100))
selfIntroduction = db.Column(db.String(250))
userLogs = db.relationship('UserLog', backref='user')
blogs = db.relationship('Blog', backref='user')
def __repr__(self):
return "<User %r>" % self.username
class GithubUser(BaseModel):
__tablename__ = 'github_users'
gid = db.Column(db.Integer, unique=True)
email = db.Column(db.String(100), unique=True)
username = db.Column(db.String(100), unique=True)
picture = db.Column(db.String(100), default='')
link = db.Column(db.String(100), default='')
def to_dict(self):
return {
key: value
for key, value in self.__dict__.items() if not key.startswith('_')
}
class Blog(db.Model):
__tablename__ = 'blog'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
text = db.Column(db.Text)
sendTime = db.Column(db.DateTime, default=datetime.now())
modifyTime = db.Column(db.DateTime)
userId = db.Column(db.ForeignKey('user.id'))
def __repr__(self):
return "<Blog %r>" % self.title
class Tag(BaseModel):
__tablename__ = 'tags'
name = db.Column(db.String(length=100), unique=True)
@classmethod
def get_by_name(cls, name):
return cls.query.filter_by(name=name).first()
@classmethod
def create(cls, **kwargs):
name = kwargs.pop('name')
kwargs['name'] = name.lower()
return super().create(**kwargs)
class Post(CommentMixin, ReactMixin, BaseModel):
__tablename__ = 'posts'
STATUSES = (
STATUS_UNPUBLISHED,
STATUS_ONLINE
) = range(2)
TYPES = (TYPE_ARTICLE, TYPE_PAGE) = range(2)
title = db.Column(db.String(length=100), unique=True)
author_id = db.Column(db.Integer)
slug = db.Column(db.String(length=100))
summary = db.Column(db.String(length=255))
can_comment = db.Column(db.Boolean, default=True)
status = db.Column(db.Integer, default=STATUS_UNPUBLISHED)
type = db.Column(db.Integer, default=TYPE_ARTICLE)
kind = K_POST
@classmethod
def create(cls, **kwargs):
tags = kwargs.pop('tags', [])
content = kwargs.pop('content')
obj = super().create(**kwargs)
if tags:
PostTag.update_multi(obj.id, tags)
obj.set_content(content)
return obj
def update_tags(self, tagnames):
if tagnames:
PostTag.update_multi(self.id, tagnames)
return True
@property
@cache(MC_KEY_TAGS_BY_POST_ID % ('{self.id}'))
def tags(self):
pts = PostTag.query.filter_by(post_id=self.id).all()
if not pts:
return []
ids = [pt.tag_id for pt in pts]
return Tag.query.filter(Tag.id.in_(ids)).all()
@property
def author(self):
from app.models import User
return User.query.get(self.author_id)
def preview_url(self):
return f'/{self.__class__.__name__.lower()}/{self.id}/preview'
def set_content(self, content):
return self.set_props_by_key('content', content)
def save(self, **kwargs):
content = kwargs.pop('content', None)
if content is not None:
self.set_content(content)
return super().save()
@property
def content(self):
rv = self.get_props_by_key('content')
if rv:
return rv.decode('utf-8')
@property
def html_content(self):
content = self.content
if not content:
return ''
return markdown(content)
@property
def excerpt(self):
if self.summary:
return self.summary
s = MLStripper()
s.feed(self.html_content)
return trunc_utf8(BQ_REGEX.sub('', s.get_data()).replace('\n', ''), 100)
@property
def toc(self):
content = self.content
if not content:
return ''
toc.reset_toc()
toc_md.parse(content)
return toc.render_toc(level=4)
@cache(MC_KEY_RELATED % ('{self.id}'), ONE_HOUR)
def get_related(self, limit=4):
tag_ids = [tag.id for tag in self.tags]
if not tag_ids:
return []
post_ids = set(PostTag.query.filter(
PostTag.post_id != self.id, PostTag.tag_id.in_(tag_ids))
.with_entities(PostTag.post_id).all())
excluded_ids = (self.query.filter(Post.status != self.STATUS_ONLINE)
.with_entities(Post.id).all())
post_ids -= set(excluded_ids)
try:
post_ids = random.sample(post_ids, limit)
except ValueError:
pass
return self.get_multi(post_ids)
def clear_mc(self):
clear_mc(MC_KEY_RELATED % self.id)
clear_mc(MC_KEY_POST_BY_SLUG % self.slug)
for key in [MC_KEY_FEED, MC_KEY_SITEMAP, MC_KEY_SEARCH,
MC_KEY_ARCHIVES, MC_KEY_TAGS]:
clear_mc(key)
for i in [True, False]:
clear_mc(MC_KEY_ALL_POSTS % i)
clear_mc(MC_KEY_ARCHIVE % self.created_at.year)
for tag in self.tags:
clear_mc(MC_KEY_TAG % tag.id)
@classmethod
@cache(MC_KEY_POST_BY_SLUG % '{slug}')
def get_by_slug(cls, slug):
return cls.query.filter_by(slug=slug).first()
@classmethod
@cache(MC_KEY_ALL_POSTS % '{with_page}')
def get_all(cls, with_page=True):
if with_page:
return cls.query.filter_by(status=cls.STATUS_ONLINE).order_by(
cls.id.desc()).all()
return cls.query.filter_by(status=cls.STATUS_ONLINE,
type=cls.TYPE_ARTICLE).order_by(
cls.id.desc()).all()
@classmethod
def cache(cls, ident):
if str(ident).isdigit() or hasattr(ident, 'post_id'):
return super().cache(ident)
return cls.get_by_slug(ident)
@property
def is_page(self):
return self.type == self.TYPE_PAGE
@property
def url(self):
return f'/page/{self.slug}' if self.is_page else super().url