class TaskItem(db.Model):
"""
任务
"""
__tablename__ = "task_item"
TODO = 1
DONE = 2
id = db.Column(db.Integer, primary_key=True)
owner = db.Column(db.Unicode(255))
name = db.Column(db.Unicode(255))
status = db.Column(db.Integer, default=TODO)
desc = db.Column(db.Unicode(255))
note = db.Column(db.UnicodeText)
list_id = db.Column(db.Integer)
due_date = db.Column(db.DateTime, index=True)
created_at = db.Column(db.DateTime, index=True, default=datetime.now)
update_at = db.Column(db.DateTime, index=True, default=datetime.now)
__mapper_args__ = {'order_by': [id]}
def __repr__(self):
return '<TaskItem %s>' % self.name
def __unicode__(self):
return self.name
class VarGroups(db.Model):
__tablename__ = 'variables_groups'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
variable_id = db.Column(db.Integer, db.ForeignKey('yjvariableinfo.id'))
group_id = db.Column(db.Integer, db.ForeignKey('yjgroupinfo.id'))
variable = db.relationship('YjVariableInfo', back_populates='groups')
group = db.relationship('YjGroupInfo', back_populates='variables')
class ImagesModel(db.Model):
__tablename__ = 'image'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
url = db.Column(db.String(150))
book_id = db.Column(db.String(100), db.ForeignKey("book.id"))
book = db.relationship("BookModel", backref='images')
class DBData(db.Model):
__tablename__ = 'data'
index = db.Column(db.INT, primary_key=True, autoincrement=True)
task_id = db.Column(db.INT)
step = db.Column(db.TEXT)
data = db.Column(db.TEXT)
class TransferLog(db.Model):
__tablename__ = 'logs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
station_id = db.Column(db.Integer, db.ForeignKey('yjstationinfo.id'))
level = db.Column(db.Integer)
time = db.Column(db.Integer)
note = db.Column(db.String(200))
class UserInfo(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
realname = db.Column(db.String(20))
gender = db.Column(db.Boolean, default=False)
def __str__(self):
return self.realname
class Article(BaseMixin, db.Model):
__tablename__ = 'articles'
article_id = db.Column(db.String(10), primary_key=True)
title = db.Column(db.String(20), default='')
brief = db.Column(db.String(100), default='')
tag = db.Column(db.String(10), default='')
content = db.Column(db.String(3000), default='')
class UserDeposit(db.Model):
__tablename__ = 'userdeposit'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
userid = db.Column(db.Integer, db.ForeignKey('userinfo.id'))
amount = db.Column(db.Numeric)
createdate = db.Column(db.Text)
fromid = db.Column(db.Integer)
class UserCredit(db.Model):
__tablename__ = 'usercredit'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
userid = db.Column(db.Integer, db.ForeignKey('userinfo.id'))
wayid = db.Column(db.Integer, db.ForeignKey('creditway.id'))
amount = db.Column(db.BigInteger)
createdate = db.Column(db.Text)
class Couple(db.Model, TrackModifications):
__tablename__ = TABLE_COUPLE
__table_args__ = (db.UniqueConstraint("lead_id",
"follow_id",
name="_lead_follow_uc"), )
id = db.Column(db.Integer(), primary_key=True)
lead_id = db.Column(
db.Integer(), db.ForeignKey(f"{TABLE_PERSON}.id", ondelete="CASCADE"))
lead = db.relationship("Person", foreign_keys=lead_id)
follow_id = db.Column(
db.Integer(), db.ForeignKey(f"{TABLE_PERSON}.id", ondelete="CASCADE"))
follow = db.relationship("Person", foreign_keys=follow_id)
def __repr__(self):
return f"{self.lead}-{self.follow}"
def json(self):
data = {
"id": self.id,
"lead": {
"id": self.lead.id,
"full_name": self.lead.full_name,
},
"follow": {
"id": self.follow.id,
"full_name": self.follow.full_name,
},
"couple": f"{self.lead.full_name} & {self.follow.full_name}"
}
return data
class Article(db.Model):
__tablename__ = 'article'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
title = db.Column(db.String(30), nullable=False)
content = db.Column(db.Text, nullable=False)
praise = db.Column(db.Integer, default=0)
marvellous = db.Column(db.Boolean, default=False)
create_time = db.Column(db.DateTime, default=datetime.now)
last_update_time = db.Column(db.DateTime, onupdate=datetime.now)
can_read = db.Column(db.Boolean, default=True)
user_id = db.Column(db.String(100),
db.ForeignKey('front_user.id', ondelete='CASCADE'))
model_id = db.Column(db.Integer,
db.ForeignKey('model.id', ondelete='CASCADE'))
model = db.relationship(Model,
backref=db.backref('articles', lazy='dynamic'),
cascade='all')
user = db.relationship(FrontUser,
backref=db.backref('articles', lazy='dynamic'),
cascade='all')
def update_article(self, title, content):
self.title = title
self.content = content
def __add__(self, other):
self.praise += 1
def __sub__(self, other):
self.praise -= 1
class User(db.Model):
__tablename__ = 'user'
__table_args__ = {'mysql_charset': 'utf8'}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(64), unique=True, nullable=False)
password = db.Column(db.String(64), nullable=False)
posts = db.relationship('Post', backref='user', lazy='dynamic')
albums = db.relationship('Album', backref='user', lazy='dynamic')
pictures = db.relationship('Picture', backref='user', lazy='dynamic')
def __init__(self, username):
self.username = username
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
@staticmethod
def get_user_by_username_and_password(username, password):
user = User.query.filter(User.username == username).first()
if user:
if user.check_password(password):
return user
else:
return None
else:
return None
class Questions(db.Model):
__tablename__ = 't_question'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question = db.Column(db.String(255))
answer = db.Column(db.Text)
answer_type = db.Column(db.String(255))
keywords = db.Column(db.String(255))
class MessageLogZwzx(db.Model):
__tablename__ = 'message_log_dept_zwzx'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
content = db.Column(db.Text)
message_sender = db.Column(db.String(255))
message_type = db.Column(db.String(255))
message_createtime = db.Column(db.String(255))
class USER(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
password = db.Column(db.String(100))
def __init__(self, name, password):
self.name = name
self.password = password
@classmethod
def check_login(cls, user, passwd):
user = cls.query.filter_by(name=user).first()
if user:
if passwd == user.password:
return {'msg': 'ok'}
else:
return {'msg': 'passwd error'}
else:
return {'msg': 'not found user'}
@classmethod
def resgiter(cls, user, passwd):
msg = cls.check_login(user, passwd)
if msg['msg'] != 'not found user':
return 'resgitered'
else:
new_user = cls(name=user, password=passwd)
return new_user
def __repr__(self):
return '<user:%s>' % self.name
class UserDistribution(db.Model):
__tablename__ = 'userdistribution'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
userid = db.Column(db.Integer, db.ForeignKey('userinfo.id'))
courseid = db.Column(db.Integer, db.ForeignKey('courseinfo.id'))
radio = db.Column(db.Numeric)
link = db.Column(db.Text)
class LoginUser(db.Model):
__tablename__ = 'login_user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(250), unique=True, nullable=False)
username = db.Column(db.String(250), unique=True, nullable=False)
password = db.Column(db.String(250))
login_time = db.Column(db.Integer)
def __init__(self, id, username, password, email):
self.id = id
self.username = username
self.password = generate_password_hash(password)
self.email = email
def __str__(self):
return "Users(id='%s')" % self.id
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
def get(self, username):
return self.query.filter_by(username=username).first()
def add(self):
db.session.add(self)
return session_commit()
def update(self):
db.session.add(self)
return session_commit()
class VideoCommentSecond(db.Model):
__tablename__ = 'videocommentsecond'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
userid = db.Column(db.Integer, db.ForeignKey('userinfo.id'))
videoid = db.Column(db.Integer, db.ForeignKey('videoinfo.id'))
commentid = db.Column(db.Integer, db.ForeignKey('videocomment.id'))
to = db.Column(db.Integer, db.ForeignKey('userinfo.id'))
class User(db.Model):
__tablename__ = 'users2'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
def __init__(self, name):
self.name = name
class Chart(db.Model):
__tablename__ = 'chart'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
userid = db.Column(db.Integer, db.ForeignKey('userinfo.id'))
teacherid = db.Column(db.Integer, db.ForeignKey('teacherinfo.id'))
content = db.Column(db.Text)
createDate = db.Column(db.Text)
class FrontUser(db.Model):
__tablename__ = "front_user"
id = db.Column(db.String(100), primary_key=True, default=shortuuid.uuid)
telephone = db.Column(db.String(11), nullable=False, unique=True)
username = db.Column(db.String(30), nullable=False)
_password = db.Column(db.String(100), nullable=False)
email = db.Column(db.String(50), unique=True)
realname = db.Column(db.String(50))
avatar = db.Column(db.String(100)) # 头像
signature = db.Column(db.String(100)) # 签名
gender = db.Column(db.Enum(GenderEnum), default=GenderEnum.UNKNOW)
join_time = db.Column(db.DateTime, default=datetime.datetime.now)
# 因为要特殊处理password
def __init__(self, password, **kwargs):
self.password = password
kwargs.pop('password', None)
super(FrontUser, self).__init__(**kwargs)
@property
def password(self):
return self._password
@password.setter
def password(self, frontpwd):
# 1. 密码不希望外界访问 2.防止循环引用
self._password = generate_password_hash(frontpwd)
def checkPwd(self, frontpwd):
# return self.password == generate_password_hash(frontpwd)
return check_password_hash(self._password, frontpwd)
class TeacherInfo(db.Model):
__tablename__ = 'teacherinfo'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
phone = db.Column(db.String(64), primary_key=True)
name = db.Column(db.String(64))
info = db.Column(db.Text)
favor = db.Column(db.Float)
class DBUser(db.Model):
__tablename__ = 'user'
index = db.Column(db.INT, primary_key=True, autoincrement=True)
user_id = db.Column(db.String(16), nullable=False, unique=True)
password = db.Column(db.TEXT, nullable=False)
username = db.Column(db.TEXT)
class User(db.Model):
# autoincrement 自增长
uid = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(30))
password_hash = db.Column(db.String(128), nullable=False)
# 对应的数据库中的表名
__tablename__ = 'user'
class VarQueries(db.Model):
__tablename__ = 'variables_queries'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
query_id = db.Column(db.Integer, db.ForeignKey('query_group.id'))
variable_id = db.Column(db.Integer, db.ForeignKey('yjvariableinfo.id'))
query = db.relationship('QueryGroup', back_populates='variables')
variable = db.relationship('YjVariableInfo', back_populates='queries')
class Question(db.Model):
__tablename__ = 'questions'
id = db.Column(db.Integer,primary_key=True,autoincrement=True)
title = db.Column(db.String(100),nullable=False)
content = db.Column(db.Text,nullable=False)
create_time = db.Column(db.DateTime,index=True,default=datetime.utcnow)
author_id = db.Column(db.Integer,db.ForeignKey('users.id'))
class Group(CoreMixin, db.Model):
__tablename__ = 'groups'
id = db.Column(db.String(20), primary_key=True) # puid
owner_id = db.Column(db.String(20), index=True)
nick_name = db.Column(db.String(60), index=True)
def __repr__(self):
return '<Group %r>' % self.nick_name
@hybrid_method
def is_member(self, user):
return user in self.members
@hybrid_method
def add_member(self, user):
if not self.is_member(user):
self.members.append(user)
@hybrid_method
def del_member(self, user):
if self.is_member(user):
self.members.remove(user)
@hybrid_property
def count(self):
return len(self.members)
def to_dict(self):
rs = super().to_dict()
rs['count'] = self.count
return rs
class TODO(db.Model):
__tablename__ = 'todo'
id = db.Column(db.Integer, primary_key=True)
user = db.Column(db.String(100))
todo = db.Column(db.String(100), unique=True)
created = db.Column(db.DateTime, default=datetime.now())
description = db.Column(db.String(200))
def __init__(self, user, todo, description, created=datetime.now()):
self.user = user
self.todo = todo
self.created = created
self.description = description
@classmethod
def get_todo(cls, user):
todos = cls.query.filter_by(user=user)
todo_list = []
for each in todos:
todo_dict = {}
todo_dict['id'] = each.id
todo_dict['todo'] = each.todo
todo_dict['created'] = each.created
todo_dict['description'] = each.description
todo_list.append(todo_dict)
return todo_list
def __repr__(self):
return '<todo:%s>' % self.todo
class DancingClassCouple(db.Model, TrackModifications):
__tablename__ = TABLE_DANCING_CLASS_COUPLE
__table_args__ = (
db.UniqueConstraint("dancing_class_id", "person_id", "partner_id", name="_dancing_class_couple_uc"),
)
id = db.Column(db.Integer(), primary_key=True)
dancing_class_id = db.Column(db.Integer(), db.ForeignKey(f"{TABLE_DANCING_CLASS}.id", ondelete="CASCADE"),
nullable=False)
dancing_class = db.relationship("DancingClass", lazy=False)
person_id = db.Column(db.Integer(), db.ForeignKey(f"{TABLE_DANCING_CLASS_PERSON}.id", ondelete="CASCADE"),
nullable=False)
person = db.relationship("DancingClassPerson", foreign_keys=person_id, lazy=False)
partner_id = db.Column(db.Integer(), db.ForeignKey(f"{TABLE_DANCING_CLASS_PERSON}.id", ondelete="CASCADE"),
nullable=False)
partner = db.relationship("DancingClassPerson", foreign_keys=partner_id, lazy=False)
def __repr__(self):
return f"{self.person} - {self.partner}"
def json(self):
data = {
"id": self.id,
"lead": self.person.json(),
"follow": self.partner.json(),
}
return data
class ESGSimpleDemoModel(db.Model):
__tablename__ = 'esg_simple_demo_model'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
company_name = db.Column(db.String(64), nullable=False)
setup_date = db.Column(db.DateTime, default=datetime.datetime.utcnow())
# def __init__(self,casename,serial_number,pass_or_not,test_date,
# error_type,error_message,status,time_consume,test_set_id):
# self.casename = casename
# self.serial_number = serial_number
# self.pass_or_not = pass_or_not
# self.test_date = test_date
# self.error_type = error_type
# self.error_message = error_message
# self.status = status
# self.time_consume = time_consume
# self.test_set_id = test_set_id
def serialize(self):
return {
'id': str(self.id),
'company_name': self.company_name,
'setup_date': self.setup_date,
}
