class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80))
email = db.Column(db.String(120))
password = db.Column(db.String(80))
def __init__(self, username, email, password):
self.username = username
self.password = password
self.email = email
def save_to_db(self):
db.session.add(self)
db.session.commit()
def json(self):
return {'id': self.id, 'username': self.username, 'email': self.email}
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class AnsibleTasks(db.Model):
"""ansible任务表"""
__tablename__ = 'ansibletask'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
ansible_id = db.Column(db.String(80), unique=True, nullable=True)
celery_id = db.Column(db.String(80), unique=True, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
group_name = db.Column(db.String(80), nullable=True)
playbook = db.Column(db.String(80), unique=False, nullable=True)
extra_vars = db.Column(db.Text, nullable=True)
option_id = db.Column(db.Integer, db.ForeignKey('options.id', ondelete='SET NULL'), nullable=True)
# True: 任务执行完成 False: 任务执行中
status_choices = (
(1, '执行中'),
(2, '已完成'),
(3, '任务失败'),
(4, '任务取消')
)
state = db.Column(ChoiceType(status_choices, db.Integer()), nullable=False, default=0, comment="任务状态")
# state = db.Column(db.Boolean, default=False, nullable=False)
ansible_result = db.Column(db.Text(16777216))
celery_result = db.Column(db.Text)
create_time = db.Column(db.DateTime, default=datetime.datetime.now)
cancelled = db.Column(db.Boolean, nullable=False, default=False)
user = db.relationship('User')
option = db.relationship('Options')
# 排序
__mapper_args__ = {
"order_by": create_time.desc(),
}
def __repr__(self):
return "<{}: {}>".format(self.__class__.__name__, self.ansible_id)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
watch_queue = db.relationship('Series',
secondary=association_table,
backref=db.backref('queue', lazy='dynamic'))
class HostGroup(db.Model):
"""主机组表"""
__tablename__ = 'host_group'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
name = db.Column(db.String(48), nullable=False, unique=True)
description = db.Column(db.String(128))
# 关系定义,不会在数据库中生成字段
hosts = db.relationship('Host', back_populates='group')
def __repr__(self):
return '<HostGroup %r>' % self.name
class Host(db.Model):
"""主机表"""
__tablename__ = 'host'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
hostname = db.Column(db.String(60), nullable=False, unique=True)
ip = db.Column(db.String(20), nullable=False, unique=True)
port = db.Column(db.Integer, nullable=False, default=22)
group_id = db.Column(db.Integer, db.ForeignKey('host_group.id'), nullable=True)
# 关系标量
group = db.relationship('HostGroup', back_populates='hosts')
def __repr__(self):
return '<Host %r>' % self.hostname
class Series(db.Model):
__tablename__ = 'series'
id = db.Column(db.Integer, primary_key=True)
kitsu_id = db.Column(db.Integer, nullable=True)
canonical_title = db.Column(db.String(120), nullable=True)
en_title = db.Column(db.String(120), nullable=True)
en_jp_title = db.Column(db.String(120), nullable=True)
attributes = db.relationship('Attribute', uselist=False, backref='series')
cover_image = db.relationship('CoverImage',
uselist=False,
backref='series')
poster_image = db.relationship('PosterImage',
uselist=False,
backref='series')
class Post(db.Model):
"""wiki文章表"""
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
title = db.Column(db.String(60), nullable=False, comment="文章标题")
desc = db.Column(db.String(180), comment="文章摘要")
body = db.Column(db.Text)
published = db.Column(db.Boolean, nullable=False, default=False, comment="文档发布状态")
create_time = db.Column(db.DateTime, default=datetime.datetime.now, comment="创建时间")
update_time = db.Column(db.DateTime, default=datetime.datetime.now, comment="更新时间")
# 与分类表关联
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
# 作者
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
author = db.relationship('User', back_populates='posts')
class UserModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True)
password = db.Column(db.String(512), nullable=False)
favourite_articles = db.Column(db.ARRAY(db.Integer), default=[])
favourite_services = db.Column(db.ARRAY(db.String), default=[])
has_been_initialized = db.Column(db.Boolean, default=False)
show_fav_as_default = db.Column(db.Boolean, default=False)
def commit_db(self):
db.session.commit()
def delete_user(self):
self.query.delete()
self.commit_db()
class Options(db.Model):
"""playbook选项参数"""
__tablename__ = 'options'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
name = db.Column(db.String(48), nullable=False)
content = db.Column(db.Text, nullable=True)
playbook_id = db.Column(db.Integer, db.ForeignKey('playbook.id'), nullable=False)
env_id = db.Column(db.Integer, db.ForeignKey('environment.id'))
url = db.Column(db.String(128), nullable=True)
playbook = db.relationship('PlayBook')
env = db.relationship('Environment')
def __repr__(self):
return '<Options %r>' % self.name
class Attribute(db.Model):
id = db.Column(db.Integer, primary_key=True)
synopsis = db.Column(db.Text, nullable=True)
rating = db.Column(db.Integer, nullable=True)
rating_rank = db.Column(db.Integer)
favorites_count = db.Column(db.Integer)
popularity_rank = db.Column(db.Integer)
start_date = db.Column(db.String(15), nullable=True)
end_date = db.Column(db.String(15))
status = db.Column(db.Text)
episode_count = db.Column(db.Integer)
episode_length = db.Column(db.Integer)
nsfw = db.Column(db.Boolean)
series_id = db.Column(db.Integer,
db.ForeignKey('series.id'),
nullable=False)
class PlayBook(db.Model):
"""playbook表"""
__tablename__ = 'playbook'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
name = db.Column(db.String(48), nullable=False, unique=True)
author = db.Column(db.String(20), nullable=False)
information = db.Column(db.String(48), nullable=False, unique=True)
is_env = db.Column(db.Boolean, nullable=False, default=False)
upload = db.Column(db.Boolean, nullable=False, default=False)
step = db.Column(db.Integer, nullable=True)
# 建立一对一关系
detail = db.relationship('PlayBookDetail', back_populates='playbook', uselist=False, cascade='all')
def __repr__(self):
return '<PlayBook %r>' % self.name
class User(db.Model):
"""User model
"""
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean, default=True)
is_admin = db.Column(db.Boolean, default=False)
examples = db.relationship("Example", backref="user", lazy=True)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.password = pwd_context.hash(self.password)
def __repr__(self):
return "<User %s>" % self.email
class Environment(db.Model):
"""环境信息"""
__tablename__ = 'environment'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), nullable=False)
def __repr__(self):
return '<Environment %r>' % self.name
class User(db.Model):
"""用户表"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(48), unique=True, nullable=False)
email = db.Column(db.String(64), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
bucket = db.Column(db.String(64), nullable=True, comment="用户桶名称")
use_space = db.Column(db.Integer, default=0, comment="用户已使用空间")
avatar_s = db.Column(db.String(64))
avatar_m = db.Column(db.String(64))
avatar_l = db.Column(db.String(64))
# 邮箱确认字段
confirmed = db.Column(db.Boolean, default=False)
posts = db.relationship('Post', back_populates='author')
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.generate_avatar()
def generate_avatar(self):
avatar = Identicon()
filenames = avatar.generate(text=self.username)
self.avatar_s = filenames[0]
self.avatar_m = filenames[1]
self.avatar_l = filenames[2]
db.session.commit()
def __repr__(self):
return '<User %r>' % self.username
class TokenBlacklist(db.Model):
"""Blacklist representation
"""
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(36), nullable=False, unique=True)
token_type = db.Column(db.String(10), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
revoked = db.Column(db.Boolean, nullable=False)
expires = db.Column(db.DateTime, nullable=False)
user = db.relationship("User", lazy="joined")
def to_dict(self):
return {
"token_id": self.id,
"jti": self.jti,
"token_type": self.token_type,
"user_identity": self.user_identity,
"revoked": self.revoked,
"expires": self.expires,
}
class RevokedTokenModel(db.Model):
__tablename__ = 'revoked_tokens'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120))
def add(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
class ArticleModel(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(512), nullable=False)
title = db.Column(db.String(512), nullable=False)
url = db.Column(db.String(512), nullable=False)
author = db.Column(db.String(128), nullable=False)
upload_date = db.Column(db.DateTime, nullable=False)
hash = db.Column(db.String(512), nullable=False)
def __init__(self, **kwargs: Any) -> None:
super().__init__(**kwargs)
self.hash: bytes = self.set_hash()
def set_hash(self) -> bytes:
data_to_encode = '{name}-{date}-{author}-{url}'.format(
name=self.name,
date=self.upload_date,
author=self.author,
url=self.url)
return b64encode(data_to_encode.encode('utf-8')).decode('utf-8')
def get_article(self) -> dict:
return {
'id': self.id,
'url': self.url,
'title': self.title,
'name': self.name,
'author': self.author,
'upload_date': self.upload_date,
'hash': str(self.hash)
}
def save(self) -> None:
db.session.add(self)
def exist(self) -> bool:
return self.query.filter_by(hash=self.hash).scalar() is not None
class Example(db.Model):
"""Example - to be changed
"""
id = db.Column(db.Integer, primary_key=True)
search_query = db.Column(db.String(1500), nullable=True)
search_tags = db.Column(db.Text, nullable=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __init__(self, **kwargs):
super(Example, self).__init__(**kwargs)
def __repr__(self):
return "<Example %s>" % self.id
class FileRepository(db.Model):
"""文件库"""
__tablename__ = 'file_repository'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
file_type_choices = (
(1, '文件'),
(2, '文件夹')
)
file_type = db.Column(ChoiceType(file_type_choices, db.Integer()), nullable=True, comment="文件类型")
name = db.Column(db.String(64), nullable=False, comment="文件/文件夹名称")
key = db.Column(db.String(128), nullable=True, comment="文件存储在OSS中的KEY")
file_size = db.Column(db.Integer, nullable=True, comment="文件大小/字节")
file_path = db.Column(db.String(255), nullable=True, comment="文件路径")
parent_id = db.Column(db.Integer, db.ForeignKey('file_repository.id'), nullable=True, comment="父级目录id")
update_datetime = db.Column(db.DateTime, default=datetime.datetime.now, comment="更新时间")
user = db.relationship('User')
parent = db.relationship('FileRepository', remote_side=[id], back_populates='childs')
childs = db.relationship('FileRepository', back_populates='parent', cascade='all')
def __repr__(self):
return "<{}: {}>".format(self.__class__.__name__, self.id)
class TimeReport(ResourceMixin, db.Model):
__tablename__ = 'timereports'
id = db.Column(db.Integer, primary_key=True)
# Timereport entry details
report_id = db.Column(db.Integer, nullable=False)
date = db.Column(db.DateTime, nullable=False)
hours_worked = db.Column(db.Float, nullable=False)
job_group = db.Column(db.String(5), nullable=False)
employee_id = db.Column(db.Integer, nullable=False)
def __init__(self, **kwargs):
# Call Flask-SQLAlchemy's constructor.
super(TimeReport, self).__init__(**kwargs)
@classmethod
def get_total_pay(cls, hours, job_group):
"""
Calculates total pay based on hours worked and the job group
:params: hours, job_group
:return: (int)
"""
job_groups = {'A': 20, 'B': 30}
return hours * job_groups[job_group]
@classmethod
def get_payperiod(cls, date):
"""
Processes date into startDate and endDate of a pay period.
:params: date
:return: tuple(startDate, endDate)
"""
if date.day <= 15:
startDate = datetime.datetime(date.year, date.month,
1).strftime("%Y-%m-%d")
endDate = datetime.datetime(date.year, date.month,
15).strftime("%Y-%m-%d")
else:
startDate = datetime.datetime(date.year, date.month,
16).strftime("%Y-%m-%d")
endDate = datetime.datetime(
date.year, date.month,
monthrange(date.year, date.month)[1]).strftime("%Y-%m-%d")
return (startDate, endDate)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(100), nullable=False)
firstname = db.Column(db.String(100), nullable=False)
lastname = db.Column(db.String(100), nullable=False)
password = db.Column(db.String(200), nullable=False)
email = db.Column(db.String(100), nullable=False)
language = db.Column(db.String())
class Category(db.Model):
"""wiki分类表"""
__tablename__ = 'category'
id = db.Column(db.Integer, nullable=False, primary_key=True, autoincrement=True)
name = db.Column(db.String(32), unique=True, comment="分类名称")
posts = db.relationship('Post', back_populates='category')
