class RequirementModel(db.Model):
"""
需求
"""
__tablename__ = "requirement_model"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False, comment="项目名")
comments = db.Column(db.String(128), nullable=True, comment="备注")
user_mail_list = db.Column(db.Text, nullable=False, comment="用户邮箱")
# sqls = db.relationship('SQLModel', backref='project', lazy='dynamic')
# tasks = db.relationship('TasksModel', backref='project', lazy='dynamic')
task_type_id = db.Column(db.ForeignKey("task_type_model.id"))
task_type = db.relationship('TaskTypeModel',
backref=db.backref('requirement_model',
lazy='dynamic'))
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class Proxy(Base):
__tablename__ = 'proxy'
host = db.Column(db.String(255), nullable=False)
port = db.Column(db.Integer, nullable=False)
eru_container_id = db.Column(db.String(64), index=True)
cluster_id = db.Column(db.ForeignKey(Cluster.id), index=True)
suppress_alert = db.Column(db.Integer, nullable=False, default=1)
__table_args__ = (db.Index('address', 'host', 'port', unique=True), )
@cached_property
def eru_deployed(self):
return self.eru_container_id is not None
@cached_property
def eru_info(self):
import eru_utils
if eru_utils.eru_client is None or not self.eru_deployed:
return None
return eru_utils.eru_client.get_container(self.eru_container_id)
@cached_property
def cluster(self):
return Cluster.query.get(self.cluster_id)
class SQLModel(db.Model):
"""
sql
"""
__tablename__ = "sql_model"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False, comment="SQL名")
project_id = db.Column(db.ForeignKey("requirement_model.id"))
project = db.relationship('RequirementModel',
backref=db.backref('sql_model', lazy='dynamic'))
database_id = db.Column(db.ForeignKey("database_model.id"))
database = db.relationship('DatabaseModel',
backref=db.backref('sql_model', lazy='dynamic'))
content = db.Column(db.Text, nullable=False, comment="sql语句")
special_field = db.Column(db.String(64), nullable=False, comment="特殊字段")
parent_id = db.Column(db.Integer, db.ForeignKey("sql_model.id"))
parent = db.relationship("SQLModel", remote_side=[id])
parent_field = db.Column(db.String(64), nullable=False, comment="父字段")
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class BuyRankings(db.Model):
""" 购买排行(用于书籍排行) """
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
id = db.Column(db.Integer(), primary_key=True) # ID
book_id = db.Column(db.Integer(), index=True) # 书籍ID
book_name = db.Column(db.String(100)) # 书籍名称
channel_type = db.Column(db.SmallInteger(), index=True) #1男2女
author_name = db.Column(db.String(50))#作者
is_publish = db.Column(db.Integer()) # 是否出版（1：是；2：否）
status = db.Column(db.Integer())# 连载状态（1：已完结；2：未完结）
created = db.Column(db.DateTime) # 创建时间
buy_num = db.Column(db.Integer()) #购买次数
book_time = db.Column(db.DateTime) # 创建时间
def __init__(self, book_id, channel_type, author_name, is_publish, status, created, buy_num, book_name, book_time):
self.book_id = book_id
self.channel_type = channel_type
self.author_name = author_name
self.is_publish = is_publish
self.status = status
self.created = created
self.buy_num = buy_num
self.book_name = book_name
self.book_time = book_time
class TaskTypeModel(db.Model):
"""
任务类型
"""
__tablename__ = "task_type_model"
type_dict = {
1: "单sql",
2: "多sql-o2o",
3: "多sql-o2m",
4: "多sql-m2m",
}
id = db.Column(db.Integer, primary_key=True)
type_id = db.Column(db.Integer, nullable=False, default=1, comment="类型ID")
name = db.Column(db.String(128), nullable=False, comment="类型名")
comments = db.Column(db.String(128), nullable=True, comment="备注")
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __str__(self):
return self.name
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(80), unique=True)
password = db.Column(db.String(128))
last_login = db.Column(db.String(64))
def update_login_time(self):
self.last_login = datetime.utcnow().isoformat(timespec='seconds') + 'Z'
db.session.commit()
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return self.id
def __unicode__(self):
return self.username
class Proxy(Base):
__tablename__ = 'proxy'
host = db.Column(db.String(255), nullable=False)
port = db.Column(db.Integer, nullable=False)
eru_container_id = db.Column(db.String(64), index=True)
cluster_id = db.Column(db.ForeignKey(Cluster.id), index=True)
suppress_alert = db.Column(db.Integer, nullable=False, default=1)
proxy_type = db.Column(db.Integer, nullable=False, default=0)
__table_args__ = (db.Index('address', 'host', 'port', unique=True), )
@cached_property
def containerized(self):
return self.eru_container_id is not None
@cached_property
def container_info(self):
from flask import g
if g.container_client is None or not self.containerized:
return None
return g.container_client.get_container(self.eru_container_id)
@cached_property
def cluster(self):
return Cluster.query.get(self.cluster_id)
def proxy_typename(self):
if self.proxy_type == TYPE_CERBERUS:
return 'Cerberus'
elif self.proxy_type == TYPE_CORVUS:
return 'Corvus'
else:
return 'Unknow'
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
bookmarks = db.relationship('Bookmark', backref='user', lazy='dynamic')
password_hash = db.Column(db.String(256))
@property
def password(self):
raise AttributeError('Password: Write Only Field. Check the models file if you are unsure')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@staticmethod
def get_by_username(username):
return User.query.filter_by(username=username).first()
# ToDo: Add a get_userid_by_user
def __repr__(self):
return '<User %r>' % self.username
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True, index=True, nullable=False)
username = db.Column(db.String(64),
unique=True,
index=True,
nullable=False)
password = db.Column(db.String(128), nullable=False)
pic = db.Column(db.String(20), nullable=False, default='default.jpg')
post_ids = db.relationship('Post', backref='author', lazy=True)
def create_post(self, vals):
post = Post(
title=vals.get('title'),
url=vals.get('url'),
description=vals.get('description'),
user_id=self.id,
channel_id=vals.get('channel'),
)
return post
def create_channel(self, vals):
channel = Post(
title=vals.get('title'),
description=vals.get('description'),
admin_id=self.id,
)
return channel
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Teacher(db.Model):
__tablename__ = "prepods"
id = db.Column('id_61', db.Integer, primary_key=True)
full_name = db.Column('prep', db.String(100))
name = db.Column('preps', db.String(50))
raspnagr = db.relationship('Raspnagr', backref=db.backref('teacher', lazy='joined'), lazy='dynamic')
class Discipline(db.Model):
__tablename__ = "vacpred"
id = db.Column('id_15', db.Integer, primary_key=True)
title = db.Column("pred", db.String(250))
titles = db.Column("preds", db.String(250))
raspnagr = db.relationship('Raspnagr', backref=db.backref('discipline', lazy='joined'), lazy='dynamic')
class RedisNode(Base):
__tablename__ = 'redis_node'
host = db.Column(db.String(255), nullable=False)
port = db.Column(db.Integer, nullable=False)
eru_container_id = db.Column(db.String(64), index=True)
assignee_id = db.Column(db.ForeignKey(Cluster.id), index=True)
suppress_alert = db.Column(db.Integer, nullable=False, default=1)
__table_args__ = (db.Index('address', 'host', 'port', unique=True), )
def free(self):
return self.assignee_id is None
@cached_property
def eru_deployed(self):
return self.eru_container_id is not None
@cached_property
def eru_info(self):
import eru_utils
if eru_utils.eru_client is None or not self.eru_deployed:
return None
try:
return eru_utils.eru_client.get_container(self.eru_container_id)
except EruException as e:
logging.exception(e)
return {
'version': '-',
'host': '-',
'created': 'CONTAINER NOT ALIVE',
}
class Kontkurs(db.Model):
id = db.Column('id_1', db.Integer, primary_key=True)
title = db.Column("obozn")
shup = db.Column(db.Integer)
spclntion = db.Column(db.Integer)
kurs = db.Column(db.Integer)
fil = db.Column(db.Integer)
fac_id = db.Column("fac", db.Integer, db.ForeignKey('vacfac.id_5'))
aobozn_id = db.Column("aobozn", db.Integer, db.ForeignKey('vacaobozn.id_6'))
stud = db.Column(db.Integer)
groups = db.Column(db.Integer)
pgroups = db.Column(db.Integer)
smenao = db.Column(db.Integer)
smenav = db.Column(db.Integer)
groupkey = db.Column(db.Integer)
undoworksps = db.Column(db.String(250))
anothernumstudsps = db.Column(db.String(250))
newnumstud = db.Column(db.SmallInteger)
ntcgraph = db.Column(db.SmallInteger)
syear = db.Column(db.Integer)
groupslist = db.relationship('Kontgrp', backref='kontkurs', lazy='joined')
kontlist = db.relationship('Kontlist', backref='kontkurs', lazy='select')
raspnagr = db.relationship("Raspnagr", backref=db.backref('kontkurs', lazy='select'))
def __str__(self, *args, **kwargs):
return "<Kontkurs: {}>".format(self.title.strip())
def __repr__(self):
return str(self)
def get_title(self):
return self.title.replace("(И,О)", "")
class Comment(Machine, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(80), nullable=False)
content = db.Column(db.String(80), nullable=False)
created = db.Column(db.DateTime, default=datetime.utcnow())
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
status = db.Column(db.String(80), nullable=False)
def __init__(self, **kwargs):
super(Comment, self).__init__(**kwargs)
# 状态定义
states = ['wait', 'pass', 'not pass']
Machine.__init__(self, states=states, initial='wait')
self.add_transition('review', 'wait', 'pass')
self.status = 'wait'
# Machine(self, states, transitions=transitions)
def __repr__(self):
return '<Comment %r>' % self.content
def on_enter_pass(self):
self.status = 'pass'
db.session.commit()
print('wait for u')
class blogPost(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
subtitle = db.Column(db.String(50))
author = db.Column(db.String(20))
date_posted = db.Column(db.DateTime)
content = db.Column(db.Text)
class FAQ(db.Model):
id = db.Column(db.Integer, primary_key=True)
question = db.Column(db.String(128), index=True, unique=True)
answer = db.Column(db.String(128))
def __repr__(self):
return '<Question {}>'.format(self.question)
class BookCategory(db.Model):
''' 书籍分类信息 '''
__table_args__ = {'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'}
cate_id = db.Column(db.Integer(), primary_key=True) # 分类ID
cate_name = db.Column(db.String(50)) # 分类名称
parent_id = db.Column(db.Integer(), server_default='-1') # 上级ID 1:男生, 2:出版, 3:女生
showed = db.Column(db.Boolean(), server_default='1')
icon = db.Column(db.String(100))
created = db.Column(db.DateTime, server_default=func.now()) # 创建时间
def __init__(self, cate_name, parent_id=-1):
self.cate_name = cate_name
self.parent_id = parent_id
def to_dict(self):
return dict(
cate_id = self.cate_id,
cate_name = self.cate_name,
parent_id = self.parent_id,
created = self.created.strftime('%Y-%m-%d %H:%M:%S')
)
def to_admin_dict(self):
return dict(
cate_id = self.cate_id,
showed = 1 if self.showed else 0,
cate_name = self.cate_name,
parent_id = self.parent_id,
icon = self.icon if self.icon else '',
created = self.created.strftime('%Y-%m-%d %H:%M:%S')
)
class Chair(db.Model):
__tablename__ = "vackaf"
id = db.Column('id_17', db.Integer, primary_key=True)
title = db.Column("kaf", db.String(100))
short_title = db.Column("sokr", db.String(10))
raspnagr = db.relationship('Raspnagr', backref=db.backref('chair', lazy='joined'), lazy='dynamic')
class Orders(db.Model):
__tablename__ = 'orders'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.Date)
order_name = db.Column(db.String())
customer_id = db.Column(db.String())
order_items = db.relationship("Order_items")
def __init__(self, created_at, order_name, customer_id):
self.created_at = created_at
self.order_name = order_name
self.customer_id = customer_id
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self, customer={}):
return {
'id': self.id,
'created_at': self.created_at,
'order_name': self.order_name,
'customer_id': self.customer_id,
'order_items': [order_item.serialize() for order_item in self.order_items],
'customer': customer
}
class Review(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(), nullable=False)
email = db.Column(db.String(), nullable=False)
message = db.Column(db.String(), nullable=False)
apartment_id = db.Column(db.Integer, db.ForeignKey('apartment.id'))
date_comment = db.Column(db.DateTime, nullable=False, default=datetime.now)
class SmsCaptcha(db.Model):
""" 验证码记录 """
id = db.Column(db.Integer, primary_key=True)
phone = db.Column(db.String(20))
captcha = db.Column(db.String(10))
action = db.Column(db.Integer) # 0 - unknown, 1 - register 2 - reset pwd
created = db.Column(db.DateTime, server_default=func.now())
class TriggerTarget(db.Model):
__tablename__ = 'triggertargets'
id = db.Column(db.Integer, primary_key=True)
triggerID = db.Column(db.Integer, db.ForeignKey('triggers.id'))
type = db.Column(db.Enum('email', 'sms'))
address = db.Column(db.String(length=100))
snsSubscription = db.Column(db.String(length=200))
class House(db.Model):
__tablename__ = 'House'
id = db.Column(db.Integer, primary_key=True)
adress = db.Column(db.String(200, 'utf8_bin'), nullable=False)
photo = db.Column(db.String(200, 'utf8_bin'))
name = db.Column(db.String(200, 'utf8_bin'), nullable=False)
descr = db.Column(db.Text(collation='utf8_bin'), nullable=False)
class Subreddit(db.Model):
"""
"""
__tablename__ = 'subreddits_subreddit'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(SUBREDDIT.MAX_NAME), unique=True)
group = db.Column(db.String(SUBREDDIT.MAX_NAME))
description = db.Column(db.String(SUBREDDIT.MAX_DESCRIPTION))
admin_id = db.Column(db.Integer, db.ForeignKey('users_user.id'))
created_on = db.Column(db.DateTime, default=db.func.now())
updated_on = db.Column(db.DateTime,
default=db.func.now(),
onupdate=db.func.now())
threads = db.relationship('Thread', backref='subreddit', lazy='dynamic')
status = db.Column(db.SmallInteger, default=SUBREDDIT.ALIVE)
def __repr__(self):
return '<Subreddit %r>' % (self.name)
def get_threads(self, order_by='timestamp'):
"""
default order by timestamp
"""
if order_by == 'timestamp':
return self.threads.order_by(db.desc(Thread.created_on)).\
all()[:SUBREDDIT.MAX_THREADS]
else:
return self.threads.order_by(db.desc(Thread.created_on)).\
all()[:SUBREDDIT.MAX_THREADS]
def get_status(self):
"""
returns string form of status, 0 = 'dead', 1 = 'alive'
"""
return SUBREDDIT.STATUS[self.status]
def get_age(self):
"""
returns the raw age of this subreddit in seconds
"""
return (self.created_on -
datetime.datetime(1970, 1, 1)).total_seconds()
def pretty_date(self, typeof='created'):
"""
returns a humanized version of the raw age of this subreddit,
eg: 34 minutes ago versus 2040 seconds ago.
"""
if typeof == 'created':
return utils.pretty_date(self.created_on)
elif typeof == 'updated':
return utils.pretty_date(self.updated_on)
"""
class ContainerImage(Base):
__tablename__ = 'cont_image'
type = db.Column(db.Integer,
index=True,
default=TYPE_REDIS,
nullable=False)
name = db.Column(db.String(255), nullable=False, index=True, unique=True)
description = db.Column(db.String(255))
creation = db.Column(db.DateTime)
class Post(db.Model, ModelTimeMixin):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
content = db.Column(db.String(80), nullable=False)
# update_time = db.Column(db.TIMESTAMP(True), nullable=False)
# create_time = db.Column(db.TIMESTAMP(True), nullable=False, server_default=text('NOW()'))
comment = db.relationship('Comment', backref='post')
view_count = db.Column(db.Integer, default=0)
def __repr__(self):
return '<Post %r>' % self.title
class MethodDB(db.Model):
__tablename__ = "methods"
id = db.Column(db.Integer, primary_key=True)
endpoint = db.Column(db.String(512), unique=True)
acl_id = db.Column(db.Integer, db.ForeignKey("acl.id"))
acl = db.relationship("ACLDB", uselist=False, backref="methods")
comment = db.Column(db.Text)
modified = db.Column(db.DateTime(True))
created = db.Column(db.DateTime(True))
author = db.Column(db.String(64))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
def __init__(self, username, email):
self.username = username
self.email = email
def __repr__(self):
return '<User %r>' % self.username
class AdminUrl(db.Model):
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(128), unique=True)
name = db.Column(db.String(128))
def __init__(self, path, name):
self.path = path
self.name = name
def to_admin_dict(self):
return dict(id=self.id, name=self.name, path=self.path)
class Image(db.Model):
id = db.Column(db.Integer(), primary_key=True)
filename = db.Column(db.String(120))
url = db.Column(db.String(120))
created = db.Column(db.DateTime(), server_default=func.now())
def __init__(self, filename):
self.filename = self.get_filename(filename)
def get_filename(self, filename):
tmp = filename.rsplit('.', 1)
return tmp[0] + '_%s_%s.%s' % (int(
time.time()), random.randint(10000, 99999), tmp[1])
