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 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 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) avatar = db.Column(db.String) word = db.Column(db.Text, nullable=True) introduce = db.Column(db.Text, nullable=True) school = db.Column(db.String, nullable=True) def __repr__(self): return "<UserInfor %r>" % self.id
class Comment(db.Model, ModelUserMixin): __tablename__ = 'comment' id = db.Column(db.Integer, primary_key=True) content = db.Column(db.Text, nullable=False) blog_id = db.Column(db.Integer, db.ForeignKey('blog.id', ondelete="CASCADE")) blog = db.relationship('Blog', backref=db.backref('comments', cascade='all,delete-orphan', lazy='dynamic')) def __repr__(self): return "<Comment %r>" % self.content
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 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 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 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 TimeLine(db.Model, ModelUserMixin): __tablename__ = 'timeline' id = db.Column(db.Integer, primary_key=True) content = db.Column(db.Text, nullable=False) is_hidden = db.Column(db.Boolean, nullable=True, default=False) def __repr__(self): return "<TimeLine %r>" % self.content[:10] def __str__(self): return self.content[:10] @property def datetime_format(self): return format_datetime(self.created_at, 'Y-M-d H:M') def to_json(self): return {'id': self.id, 'content': self.content, 'hide': self.hide}
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 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 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 Count(db.Model): __tablename__ = 'counts' id = db.Column(db.Integer, primary_key=True) drafts = db.Column(db.Integer, default=0) collects = db.Column(db.Integer, default=0) inviteds = db.Column(db.Integer, default=0) follows = db.Column(db.Integer, default=0) topics = db.Column(db.Integer, default=0) all_topics = db.Column(db.Integer, default=0) def __repr__(self): return '<Count %r>' % self.id
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 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 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 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(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 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 }
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'))
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)
# Email: [email protected] # Created: 2016-07-24 15:10:52 (CST) # Last Update:星期六 2016-11-12 20:24:58 (CST) # By: # Description: # ************************************************************************** from maple.extension 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,
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 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, )
# -*- 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-11-12 20:20:28 (CST) # By: # Description: # ************************************************************************** from maple.extension 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,
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 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())
def __repr__(self): return "<TimeLine %r>" % self.content[:10] def __str__(self): return self.content[:10] @property def datetime_format(self): return format_datetime(self.created_at, 'Y-M-d H:M') def to_json(self): return {'id': self.id, 'content': self.content, 'hide': self.hide} tag_blog = db.Table('tag_blog', db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')), db.Column('blog_id', db.Integer, db.ForeignKey('blog.id'))) 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