class Api(db.Model):
id = db.Column(db.Integer, primary_key=True)
api_name = db.Column(db.String(50),
unique=True,
nullable=False,
index=True)
api_description = db.Column(db.String(255), nullable=False, index=True)
api_format = db.Column(db.String(50), nullable=False)
api_method = db.Column(db.String(50), nullable=False)
api_auth = db.Column(db.Boolean)
api_notice = db.Column(db.Text)
api_return = db.Column(db.Text)
api_category = db.Column(db.Integer, db.ForeignKey('category.id'))
api_test = db.Column(db.String(500))
api_view_count = db.Column(db.Integer, default=0)
api_collect_count = db.Column(db.Integer, default=0)
api_params = db.relationship('Param',
cascade="all, delete-orphan",
passive_deletes=True)
api_changelog = db.relationship('Changelog',
cascade="all, delete-orphan",
passive_deletes=True)
def __repr__(self):
return '<API %r>' % self.api_name
class User(Base,db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
nick_name = db.Column(db.String(20),index=True)
password_has = db.Column(db.String(200), nullable=False)
mobile = db.Column(db.String(11), nullable=False)
avatar_url = db.Column(db.String(256))
last_login = db.Column(db.DateTime)
signature = db.Column(db.String(512))
gender = db.Column(db.String(10),default='Man',nullable=False)
news = db.relationship('News',backref='author',lazy='dynamic')
news_collection = db.relationship('News',secondary=table_user_news
,backref='users',lazy='dynamic')
def to_dict(self):
user_list = {
'id': self.id,
'nick_name' :self.nick_name,
'password_has' : self.password_has,
'mobile' : self.mobile,
'avatar_url' : self.avatar_url,
'last_login' : self.last_login.strftime('%Y-%m-%d %H:%M:%S'),
'signature' : self.signature,
'gender' : self.gender
}
return user_list
class Music(db.Model):
__tablename__ = 'music'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
singer = db.Column(db.String(255), nullable=False)
coverfile = db.Column(db.String(255), default='')
audiofile = db.Column(db.String(255), default='')
lrcfile = db.Column(db.String(255), default='')
privacy = db.Column(db.String(20), default='guest')
recommed = db.Column(db.Integer, default=0)
clicknum = db.Column(db.Integer, default=0)
favornum = db.Column(db.Integer, default=0)
commtnum = db.Column(db.Integer, default=0)
uuid = db.Column(db.String(255), unique=True, nullable=False)
addtime = db.Column(db.DATETIME, index=True, default=datetime.now)
lang_id = db.Column(db.Integer, db.ForeignKey('music_lang_tag.id')) # 音乐语种
style_id = db.Column(db.Integer,
db.ForeignKey('music_style_tag.id')) # 音乐流派
theme_id = db.Column(db.Integer,
db.ForeignKey('music_theme_tag.id')) # 音乐主题
emotion_id = db.Column(db.Integer,
db.ForeignKey('music_emotion_tag.id')) # 音乐心情
scene_id = db.Column(db.Integer,
db.ForeignKey('music_scene_tag.id')) # 音乐场景
admin_id = db.Column(db.Integer, db.ForeignKey('admin.id'))
favors = db.relationship('MusicFavor', backref='music')
comments = db.relationship('MusicComment', backref='music')
def __repr__(self):
return '<Music %r>' % self.title
class User(db.Model):
"""
会员
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(100), unique=True) # 昵称
pwd = db.Column(db.String(100)) # 密码
email = db.Column(db.String(100), unique=True) # 邮箱
phone = db.Column(db.String(11), unique=True) # 手机
info = db.Column(db.Text) # 个性简介
face = db.Column(db.String(255), unique=True) # 头像
add_time = db.Column(db.DateTime, index=True, default=datetime.now) # 添加时间
uuid = db.Column(db.String(255), unique=True) # 唯一标识符
userlogs = db.relationship("UserLog", backref='user') # 会员日志外键关系
comments = db.relationship("Comment", backref='user') # 评论外键关系
moviecols = db.relationship("Moviecol", backref='user') # 收藏外键关系
def __repr__(self):
return "<User %r>" % self.name
def check_pwd(self, pwd):
from werkzeug.security import check_password_hash
return check_password_hash(self.pwd, pwd)
class Album(db.Model):
__tablename__ = "album"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False) # 标题
desc = db.Column(db.TEXT) # 描述
photonum = db.Column(db.Integer, default=0) # 相册图片数量
privacy = db.Column(
db.String(20), default="public"
) # 是否私有private私有 protect_1粉丝好友可见 protect_2收藏者可见 public公开
clicknum = db.Column(db.Integer, default=0) # 相册浏览量
favornum = db.Column(db.Integer, default=0) # 相册收藏量
uuid = db.Column(db.String(255), unique=True, nullable=False) # uuid
addtime = db.Column(db.DATETIME, index=True, default=datetime.now) # 添加时间
tag_id = db.Column(db.Integer, db.ForeignKey(
"album_tag.id")) # 定义外键 tag_id 来源于album_tag表中id一个标签可有多个相册
user_id = db.Column(
db.Integer,
db.ForeignKey("user.id")) # 定义外键 user_id 来源于 user表中id 一个用户可有多个相册
favors = db.relationship(
"AlbumFavor", backref="album") # 定义相册与收藏相册关系 通过收藏表的album_id 反向查找到相册
photos = db.relationship(
"Photo", backref="album") # 定义相册与图片关系 通过图片表的album_id 反向查找到相册
def __repr__(self):
return '<Album %r>' % (self.title)
class BlogPost(db.Model):
__tablename__ = 'posts'
id = Column(Integer, primary_key=True)
headline = Column(String(255), nullable=False)
body = Column(Text)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = Column(Integer, ForeignKey('users.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category',
backref=db.backref('posts', lazy='dynamic'))
# many to many BlogPost<->Keyword
tags = db.relationship('Tag',
secondary=reltags,
lazy='subquery',
backref=db.backref('pages', lazy='dynamic'))
comments = relationship('Comments', backref='posts', lazy='dynamic')
# def __init__(self,headline,body,author):
# self.author = author
# self.headline = headline
# self.body = body
def __repr__(self):
return "BlogPost(%r, %r, %r)" % (self.headline, self.body, self.author)
class PlanEQP(db.Model): # tb_pln_eqp
__tablename__ = 'tb_pln_eqp'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
lot_id = db.Column(db.ForeignKey('tb_std_lot.id'), nullable=False)
state_id = db.Column(db.String(30), nullable=False)
start_t = db.Column(db.DateTime, default='Not Determind')
end_t = db.Column(db.DateTime, default='Not Determind')
prod_id = db.Column(db.ForeignKey('tb_std_prod.id'), nullable=False)
lot_size = db.Column(db.ForeignKey('tb_ist_lot_size.id'), nullable=False)
line_eqp_id = db.Column(db.ForeignKey('tb_std_line_eqp.id'),
nullable=False)
lot = db.relationship('StdID3',
primaryjoin='PlanEQP.lot_id == StdID3.id',
backref='pln_eqp',
lazy=True)
prod = db.relationship('StdID4',
primaryjoin='PlanEQP.prod_id == StdID4.id',
backref='pln_eqp',
lazy=True)
size = db.relationship('LotSize',
primaryjoin='PlanEQP.lot_size == LotSize.id',
backref='pln_eqp',
lazy=True)
line_eqp = db.relationship(
'StdLineEQP',
primaryjoin='PlanEQP.line_eqp_id == StdLineEQP.id',
backref='pln_eqp',
lazy=True)
class Rating(db.Model):
id = db.Column(db.Integer,primary_key=True)
lecture = db.relationship('Lecture', backref=db.backref('rating_lecture', cascade='all, delete-orphan', lazy='dynamic'))
lecture_id = db.Column(db.Integer, db.ForeignKey(Lecture.id))
user = db.relationship('User', backref=db.backref('rating_user', cascade='all, delete-orphan', lazy='dynamic'))
user_id = db.Column(db.Integer, db.ForeignKey(User.id))
total = db.Column(db.Integer, default =0)
difficulty = db.Column(db.Integer, default =0)
study_time = db.Column(db.Integer, default =0)
attendance = db.Column(db.Integer, default =0)
grade = db.Column(db.Integer, default =0)
achievement = db.Column(db.Integer, default =0)
opinion = db.Column(db.Text())
joinDATE = db.Column(db.DateTime(),default = get_current_time)
def ev2(self):
ev2 = self.difficulty /5 * 100
return ev2
def ev3(self):
ev3 = self.study_time /5 * 100
return ev3
def ev4(self):
ev4 = self.attendance /5 * 100
return ev4
def ev5(self):
ev5 = self.grade /5 * 100
return ev5
def ev6(self):
ev6 = self.achievement /5 * 100
return ev6
class Admin(db.Model):
'''
管理员
'''
# id
__tablename__ = 'admin'
id = db.Column(db.Integer, primary_key=True)
# 管理员账号
name = db.Column(db.String(100), unique=True)
# 密码
pwd = db.Column(db.String(200))
# 是否为超级管理员
is_super = db.Column(db.SmallInteger)
# 所属角色
role_id = db.Column(db.Integer,db.ForeignKey('role.id'))
# 添加时间
add_time = db.Column(db.DateTime, index=True, default=datetime.datetime.utcnow)
# 外键关系关联
# 管理员登陆日志
adminlogs = db.relationship('AdminLog', backref='admin')
# 操作日志
oplogs = db.relationship('Oplog', backref='admin')
def __repr__(self):
return "<Admin %r>" % self.name
# 密码验证
def check_pwd(self, pwd):
from werkzeug.security import check_password_hash
return check_password_hash(self.pwd, pwd)
class User(UserMixin,db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer,primary_key=True,autoincrement=True)
name = db.Column(db.String(50),nullable=False,unique=True)
pwd = db.Column(db.String(255),nullable=False)
email = db.Column(db.String(50),default=None,unique=True)
phone = db.Column(db.String(11),nullable=True,default=None)
introduce = db.Column(db.TEXT,default=None)
birthday = db.Column(db.Date,default=None)
photo = db.Column(db.String(50),default=None)
addtime = db.Column(db.DATETIME,index=True,default=datetime.now)
albums = db.relationship('Album',backref='user')
album_favors = db.relationship('AlbumFavor',backref='user')
def __repr__(self):
return '<User %r>'%self.name
# 密码加密
def __init__(self,*args,**kwargs):
name = kwargs.get('name')
pwd = kwargs.get('pwd')
email = kwargs.get('email')
birthday = kwargs.get('birthday')
photo = kwargs.get('photo')
self.name = name
# self.pwd = generate_password_hash(pwd)
self.pwd = pwd
self.email = email
self.birthday = birthday
self.photo = photo
class Post(db.Model):
__tablename__ = 'post'
query_class = PostQuery
id = db.Column(db.Integer, primary_key=True)
post_content = db.Column(db.Text)
post_title = db.Column(db.String(100))
post_name = db.Column(db.String(200), unique=True)
post_create_time = db.Column(db.DateTime, default=datetime.utcnow)
view_num = db.Column(db.Integer, default=0)
comment_count = db.Column(db.Integer, default=0)
status = db.Column(db.Integer, default=1)
author_id = db.Column(db.Integer, default=1)
post_modified_time = db.Column(db.DateTime, default=datetime.utcnow)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
categorys = db.relationship('Category', backref=db.backref(
'posts', lazy='dynamic'), lazy='select')
tags = db.relationship('Tag', secondary=article_tags,
backref=db.backref('posts', lazy='dynamic'))
tags_name = db.Column(db.Text)
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
def __repr__(self):
return '<post %r>' % self.post_title
@cached_property
def comments(self):
from apps.comment.models import Comment
allcomments = Comment.query.filter(Comment.post_id == self.id).all()
return allcomments
class Developer(db.Model):
__tablename__ = 'developers'
id = db.Column(db.Integer, primary_key=True)
dev_key = db.Column(db.String(40), unique=True, index=True)
platform = db.Column(db.String(50))
platform_id = db.Column(db.String(40), unique=True)
username = db.Column(db.String(150), index=True)
integrations = db.relationship('Integration', backref='developer')
channels = db.relationship('Channel', backref='developer')
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
pwd = db.Column(db.String(255), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
phone = db.Column(db.String(120), unique=True, nullable=False)
face = db.Column(db.String(255), unique=True, nullable=False)
jianjie = db.Column(db.TEXT)
uuid = db.Column(db.String(255), unique=True, nullable=False)
addtime = db.Column(db.DATETIME, index=True, default=datetime.now)
albums = db.relationship('Album', backref='user')
favors = db.relationship('AlbumFavor', backref='user')
articles = db.relationship('Article', backref='user')
articlefavors = db.relationship('ArticleFavor', backref='user')
articlecomments = db.relationship('ArticleComment', backref='user')
musicfavors = db.relationship('MusicFavor', backref='user')
musiccomments = db.relationship('MusicComment', backref='user')
moviefavors = db.relationship('MovieFavor', backref='user')
moviecomments = db.relationship('MovieComment', backref='user')
def __repr__(self):
return '<User %r>' % self.name
def check_pwd(self, pwd):
from werkzeug.security import check_password_hash
return check_password_hash(self.pwd, pwd)
class Article(db.Model):
__tablename__ = "article"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(300))
body = db.Column(db.Text)
pubDate = db.Column(db.DateTime, default=datetime.now())
published = db.Column(db.Boolean, nullable=False, default=False)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
category = db.relationship("Category",
secondary=post,
backref=db.backref("article", lazy="dynamic"))
counter = db.relationship("Counters", backref="article", lazy=True)
class R_Univ(db.Model):
__tablename__ = 'r_univ'
id = db.Column(db.Integer, primary_key=True)
K_Univ_id = db.Column(db.Integer, db.ForeignKey('k_univ.univ_id'))
k_univ = db.relationship('K_Univ',
backref=db.backref('r_univ',
cascade='all, delete-orphan',
lazy='dynamic'))
I_Univ_id = db.Column(db.Integer, db.ForeignKey('i_univ.univ_id'))
i_univ = db.relationship('I_Univ',
backref=db.backref('r_univ',
cascade='all, delete-orphan',
lazy='dynamic'))
class Article(db.Model):
__tablename__ = 'article'
__searchable__ = ['content', 'title']
__analyzer__ = ChineseAnalyzer()
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
author = db.Column(db.String(32))
title = db.Column(db.String(32))
content = db.Column(db.Text)
tag = db.relationship('Tag',
secondary='article_to_tag',
backref=db.backref('articles'),
lazy='dynamic')
classify_id = db.Column(db.INTEGER, db.ForeignKey('classify.id'))
classify = db.relationship('Classify', backref=db.backref('articles'))
class OperationLog(BaseModel, db.Model):
"""操作日志"""
__tablename__ = "operation_log"
id = db.Column(db.Integer, primary_key=True) # 操作编号
module = db.Column(db.String(8)) # 操作模块
operation = db.Column(db.String(32)) # 执行的操作
operation_res = db.Column(db.String(32)) # 操作结果
# create_time 已继承
update_time = None # 取消update字段
user_id = db.Column(db.Integer,
db.ForeignKey('user_profile.id')) # 外键关联user
users = db.relationship('User',
backref=backref('operation'),
foreign_keys=[user_id]) # 对应用户的操作日志
def to_dict(self):
"""将对象转换为字典数据"""
# 根据前端的需求, 返回对应字段的信息
operation_dict = {
"id": self.id,
"user_id": self.user_id,
"module": self.module,
"operation": self.operation,
"res": self.operation_res,
"time": self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return operation_dict
def __repr__(self):
str_ = "OperationLog(id={id},user_id={user_id})".format(
id=self.id, user_id=self.user_id)
return str_
class Logger(db.Model):
__tablename__ = 'logger'
id = db.Column(db.Integer, primary_key=True)
sn = db.Column(db.String(10), index=True, unique=True, nullable=False)
tipe = db.Column(db.String(12), default="arr")
location_id = db.Column(db.Integer, db.ForeignKey('location.id'), nullable=True)
tenant_id = db.Column(db.Integer, db.ForeignKey('tenant.id'), nullable=True)
logger_periodik = db.relationship('Periodik', back_populates='logger', lazy='dynamic')
temp_cor = db.Column(db.Float)
humi_cor = db.Column(db.Float)
batt_cor = db.Column(db.Float)
tipp_fac = db.Column(db.Float)
ting_son = db.Column(db.Float) # dalam centi, tinggi sonar thd dasar sungai
location = relationship('Location', backref='logger')
tenant = relationship('Tenant', back_populates='loggers')
created_at = db.Column(db.DateTime)
modified_at = db.Column(db.DateTime)
# latest_sampling = db.Column(db.DateTime)
# latest_up = db.Column(db.DateTime)
# latest_id = db.Column(db.Integer)
def __repr__(self):
return '<Device {}>'.format(self.sn)
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
article_id = db.Column(db.Integer, db.ForeignKey('article.id'))
artlcle = db.relationship('Article',
backref=db.backref('comments',
cascade='all, delete-orphan',
lazy='dynamic'))
# Bidirection relationship
'''
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
name = Column(String)
addresses = relationship("Address", backref="user")
class Address(Base):
__tablename__ = 'address'
id = Column(Integer, primary_key=True)
email = Column(String)
user_id = Column(Integer, ForeignKey('user.id'))
'''
author = db.Column(db.String(255))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
content = db.Column(db.Text())
date_created = db.Column(db.DateTime(), default=db.func.now())
likecount = db.Column(db.Integer, default=0, nullable=False)
commentcheck = db.Column(db.Integer, default=0, nullable=False)
class PlanDM(db.Model): # tb_pln_dm
__tablename__ = 'tb_pln_dm'
id = db.Column(db.String(30), primary_key=True, nullable=False)
due_d = db.Column(db.DateTime, default='Not Determind')
qty = db.Column(db.Integer, default='Not Determind')
prod_id = db.Column(db.ForeignKey('tb_std_prod.id'), nullable=False)
cst_id = db.Column(db.ForeignKey('tb_std_cst.id'), nullable=False)
prod = db.relationship('StdID4',
primaryjoin='PlanDM.prod_id == StdID4.id',
backref='pln_dm',
lazy=True)
cst = db.relationship('StdID1',
primaryjoin='PlanDM.cst_id == StdID1.id',
backref='pln_dm',
lazy=True)
class ArticleTag(db.Model):
__tablename__ = 'article_tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True, nullable=False)
#指明关系,通过标签也能找到文章
articles = db.relationship('Article', backref='article_tag')
class Device(db.Model):
__tablename__ = 'device'
id = db.Column(db.Integer, primary_key=True)
sn = db.Column(db.String(8), index=True, unique=True, nullable=False)
tipe = db.Column(db.String(12), default="arr")
lokasi_id = db.Column(db.Integer,
db.ForeignKey('lokasi.id'),
nullable=True)
periodik = db.relationship('Periodik',
back_populates='device',
lazy='dynamic')
temp_cor = db.Column(db.Float)
humi_cor = db.Column(db.Float)
batt_cor = db.Column(db.Float)
tipp_fac = db.Column(db.Float)
ting_son = db.Column(
db.Float) # dalam centi, tinggi sonar thd dasar sungai
lokasi = relationship('Lokasi', back_populates='devices')
def periodik_latest(self):
return self.periodik.order_by(Periodik.id.desc()).first()
def icon(self):
return 'arr' == self.tipe and 'cloud-download' or 'upload'
def __repr__(self):
return '<Device {}>'.format(self.sn)
class UserGroup(BaseModel, db.Model):
__tablename__ = "s_user_group"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("s_user_info.id"))
group_name = db.Column(db.String(30))
group_friend = db.relationship("GroupFriend",
backref=db.backref("s_user_group"))
class GroupInfo(BaseModel, db.Model):
__tablename__ = "s_group_info"
id = db.Column(db.Integer, primary_key=True)
group_name = db.Column(db.String(30))
avatar = db.Column(db.String(100), nullable=True)
group_user = db.relationship("GroupUserRelation",
backref=db.backref("s_group_info"))
class UserGroup(db.Model):
"""分组表"""
__tablename__ = 'group'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=True)
owner = db.Column(db.Integer, db.ForeignKey('user.id'))
g_friends = db.relationship('Friend', backref='g_friend')
class ChatInfo(BaseModel, db.Model):
__tablename__ = "s_chat_info"
id = db.Column(db.Integer, primary_key=True)
from_user_id = db.Column(db.Integer, db.ForeignKey("s_user_info.id"))
chat_info = db.Column(db.Text)
chat_user = db.relationship("ChatUserRelation",
backref=db.backref("s_chat_info"))
class Comment(BaseModel, db.Model):
"""评论"""
__tablename__ = "info_comment"
id = db.Column(db.Integer, primary_key=True) # 评论编号
user_id = db.Column(db.Integer,
db.ForeignKey("info_user.id"),
nullable=False) # 用户id
news_id = db.Column(db.Integer,
db.ForeignKey("info_news.id"),
nullable=False) # 新闻id
content = db.Column(db.Text, nullable=False) # 评论内容
parent_id = db.Column(db.Integer,
db.ForeignKey("info_comment.id")) # 父评论id
parent = db.relationship("Comment", remote_side=[id]) # 自关联
like_count = db.Column(db.Integer, default=0) # 点赞条数
def to_dict(self):
resp_dict = {
"id": self.id,
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
"content": self.content,
"parent": self.parent.to_dict() if self.parent else None,
"user": User.query.get(self.user_id).to_dict(),
"news_id": self.news_id,
"like_count": self.like_count
}
return resp_dict
class User(db.Model):
# 定义表名
__tablename__ = 'tab_user'
# 定义字段
id = db.Column(db.Integer, primary_key=True, autoincrement=True) # 用户编号
loginName = db.Column(db.String(32)) # 登录名
password = db.Column(db.String(32)) # 密码
realName = db.Column(db.String(32)) # 真实姓名
mobile = db.Column(db.String(11))
address = db.Column(db.String(255))
email = db.Column(db.String(32))
lastLoginTime = db.Column(db.Date)
status = db.Column(db.Integer)
role = db.relationship('Role', backref='user',
secondary='tab_user_role') # 关联角色表
# 将数据转换成 json 格式
def to_json(self):
data_json = {
"id": self.id,
"loginName": self.loginName,
"password": self.password,
"realName": self.realName,
"mobile": self.mobile,
"address": self.address,
"email": self.email,
"lastLoginTime": self.lastLoginTime,
"status": self.status
}
return data_json
class Role(db.Model):
__tablename__ = 'roles'
id = Column('id', db.Integer, primary_key=True)
name = Column('name', db.String(64), unique=True)
default = Column(db.Boolean, default=False, index=True)
permissions = Column(db.Integer)
users = db.relationship('Users', backref='role', lazy='dynamic')
@staticmethod
def insert_roles():
roles = {
'User': (Permission.FOLLOW | Permission.COMMENT
| Permission.WRITE_ARTICLES, True),
'Moderator':
(Permission.FOLLOW | Permission.COMMENT | Permission.WRITE_ARTICLES
| Permission.MODERATE_COMMENTS, False),
'Administrator': (0xff, False)
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.permissions = roles[r][0]
role.default = roles[r][1]
db.session.add(role)
db.session.commit()
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
category_name = db.Column(db.String(20), unique=True, nullable=False)
api = db.relationship('Api', backref='category', lazy='dynamic')
def __repr__(self):
return '<Category %r>' % self.category_name
