class GroupingModel(db.Model):
__tablename__ = 'grouping'
__table_args__ = {'schema': 'public'}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
sector_id = db.Column(db.Integer, db.ForeignKey('sector.id'))
geography_id = db.Column(db.Integer, db.ForeignKey('geography.id'))
esg_factor_id = db.Column(db.Integer, db.ForeignKey('esg_factor.id'))
analysis = db.Column(db.String(32))
@property
def serialize(self):
return {
'id': str(self.id),
'name': self.name,
'sector_id': str(self.sector_id),
'geography_id': str(self.geography_id),
'esg_factor_id': str(self.esg_factor_id),
'analysis': self.analysis
}
class PortfolioSecurityValueModel(db.Model):
__tablename__ = 'portfolio_security_value'
portfolio_id = db.Column(db.Integer,
db.ForeignKey('portfolio.id'),
primary_key=True)
security_id = db.Column(db.String(20),
db.ForeignKey('security.id'),
primary_key=True)
date_key = db.Column(db.Date, primary_key=True)
weight = db.Column(db.Float)
base_currency_value = db.Column(db.Float)
@property
def serialize(self):
return {
'portfolio_id': str(self.portfolio_id),
'security_id': self.security_id,
'date_key': str(self.date_key),
'weight': str(self.weight),
'base_currency_value': str(self.base_currency_value),
}
class Announcement(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(5000), nullable=False)
saled = db.Column(db.Boolean, default=False)
category = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
created = db.Column(DateTime(timezone=True), server_default=func.now())
reason_id = db.Column(db.Integer,
db.ForeignKey('closed.id'),
nullable=True)
user = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
city = db.Column(db.String(200), nullable=True)
address = db.Column(db.String(500), nullable=True)
images = relationship("ImagesAnnoun", backref="images_announ")
want = relationship("Want", backref="want")
recently_viewed = relationship("RecentlyViewed", backref="recently_viewed")
reason = relationship("Closed", backref="closed")
delete = db.Column(db.Boolean, default=False, unique=False)
no_exchange = db.Column(db.Boolean, default=False, unique=False)
str_want = db.Column(db.String(300), nullable=True)
class Comment(db.Model):
__tablename__ = 'comment'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
author = db.Column(db.String(20))
email = db.Column(db.String(200))
site = db.Column(db.String(200))
body = db.Column(db.Text)
from_admin = db.Column(db.Boolean, default=False)
reviewed = db.Column(db.Boolean, default=False)
timestamp = db.Column(db.DateTime, default=datetime.now, index=True)
replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))
post_id = db.Column(db.Integer, db.ForeignKey('post.id'))
post = db.relationship('Post', back_populates='comments')
replies = db.relationship('Comment',
back_populates='replied',
cascade='all, delete-orphan')
replied = db.relationship('Comment',
back_populates='replies',
remote_side=[id])
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
body = db.Column(db.Text, nullable=False)
picture = db.Column(db.LargeBinary)
# sound = db.Column(db.LargeBinary)
timestamp = db.Column(db.DateTime, default=datetime.utcnow)
answers = db.relationship('Answer', backref='parent', lazy='dynamic')
teach_id = db.Column(db.Integer, db.ForeignKey('teacher.id'))
def __repr__(self):
return '<Task {}>'.format(self.title)
class Appointment(db.Model):
__tablename__ = 'appointment'
id = db.Column(db.Integer, primary_key=True)
time = db.Column(db.Integer)
add_time = db.Column(db.Integer)
user_id = db.Column(db.ForeignKey('user.id'))
user = db.relationship('User',
backref=db.backref(
'appointments',
order_by='Appointment.time.desc()'))
def __repr__(self):
return f"Appointment('{self.time}','{self.add_time}')"
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))
def __init__(self, station_id, level, time, note):
self.station_id = station_id
self.level = level
self.time = time
self.note = note
class PortfolioEsgScoreModel(db.Model):
__tablename__ = 'portfolio_esg_score'
portfolio_id = db.Column(db.Integer,
db.ForeignKey('portfolio.id'),
primary_key=True)
date_key = db.Column(db.Date, primary_key=True)
esg_factor_id = db.Column(db.Integer,
db.ForeignKey('esg_factor.id'),
primary_key=True)
weight_method = db.Column(db.Integer)
score = db.Column(db.Float)
@property
def serialize(self):
return {
'portfolio_id': str(self.portfolio_id),
'date_key': str(self.date_key),
'esg_factor_id': str(self.esg_factor_id),
'weight_method': str(self.weight_method),
'score': str(self.score),
}
class CompanyModel(db.Model):
__tablename__ = 'company'
id = db.Column(db.String(20), primary_key=True)
ara_id = db.Column(db.String(15))
name = db.Column(db.String(200), nullable=False)
geography_id = db.Column(db.Integer, db.ForeignKey('geography.id'), nullable=False)
sector_id = db.Column(db.Integer, db.ForeignKey('sector.id'))
suppliers = db.relationship('CompanySupplierModel', foreign_keys='CompanySupplierModel.company_id')
geography = db.relationship('GeographyModel', foreign_keys=[geography_id])
sector = db.relationship('SectorModel', foreign_keys=[sector_id])
@property
def serialize(self):
return {
'id': self.id,
'ara_id': self.ara_id,
'name': self.name,
'geography_id': str(self.geography_id),
'sector_id': str(self.sector_id),
}
class Post(db.Model):
__tablename__ = 'post'
__table_args__ = {'mysql_charset': 'utf8'}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(64))
text = db.Column(db.Text)
publish_date = db.Column(db.DateTime, default=datetime.datetime.now)
publish_able = db.Column(db.String(1))
publish_state = db.Column(db.String(1))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
tag_id = db.Column(db.Integer, db.ForeignKey('tag.id'))
comments = db.relationship('Comment', backref='post', lazy='dynamic')
def __init__(self, title, text, publish_able, tag_id):
self.title = title
self.text = text
self.publish_able = publish_able
self.tag_id = tag_id
def __repr__(self):
return '<Post {}>'.format(self.title)
class Action(db.Model):
__tablename__ = 'action'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
fun_id = db.Column(db.Integer,
db.ForeignKey('function_info.id'),
nullable=False,
comment="方法id")
ele_id = db.Column(db.Integer,
db.ForeignKey('element.id'),
comment="所操作元素id")
page_id = db.Column(db.Integer, db.ForeignKey('page.id'), comment="所属页面ID")
create_datetime = db.Column(db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
comment="创建时间")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
fun = db.relationship('FunctionInfo')
ele = db.relationship('Element')
class YjPLCInfo(db.Model):
__tablename__ = 'yjplcinfo'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
plc_name = db.Column(db.String(30))
note = db.Column(db.String(200))
ip = db.Column(db.String(30))
mpi = db.Column(db.Integer)
type = db.Column(db.Integer)
plc_type = db.Column(db.String(20))
ten_id = db.Column(db.String(255))
item_id = db.Column(db.String(20))
rack = db.Column(db.Integer)
slot = db.Column(db.Integer)
tcp_port = db.Column(db.Integer)
station_id = db.Column(db.Integer, db.ForeignKey('yjstationinfo.id'))
groups = db.relationship('YjGroupInfo',
backref='yjplcinfo',
lazy='dynamic',
cascade="delete, delete-orphan")
def __init__(self,
plc_name=None,
station_id=None,
note=None,
ip=None,
mpi=None,
type=None,
plc_type=None,
ten_id=None,
item_id=None,
rack=0,
slot=0,
tcp_port=102):
self.plc_name = plc_name
self.station_id = station_id
self.note = note
self.ip = ip
self.mpi = check_int(mpi)
self.type = type
self.plc_type = plc_type
self.ten_id = ten_id
self.item_id = item_id
self.rack = rack
self.slot = slot
self.tcp_port = tcp_port
def __repr__(self):
return '<PLC : ID(%r) Name(%r) >'.format(self.id, self.plc_name)
class Post(BaseMixin,db.Model):
__tablename__ = 'posts'
name = db.Column(db.String(255),nullable=False)
content = db.Column(db.Text)
blog_id = db.Column(db.Integer,db.ForeignKey('blogs.id'))
blog = db.relationship('Blog',backref=db.backref(
'posts'),uselist=False)
category_id = db.Column(db.Integer,db.ForeignKey('categories.id'))
category = db.relationship('Category',backref=db.backref(
'posts'),uselist=False)
#tags = db.relationship('Tag',secondary='posts_tags',backref=db.backref(
# 'posts',lazy='dynamic'),lazy='dynamic')
author_id = db.Column(db.Integer,db.ForeignKey('users.id'))
author = db.relationship('User',backref=db.backref(
'posts'),uselist=False)
date_added = db.Column(db.DateTime,default=db.func.now())
date_modified = db.Column(db.DateTime,default=db.func.now(),onupdate=db.func.now())
excerpt_length = db.Column(db.Integer,default=55,nullable=False)
slug = db.Column(db.String(255),unique=True)
icon_id = db.Column(db.Integer,db.ForeignKey('font_icons.id'))
icon = db.relationship('FontIcon',backref='posts')
@property
def comment_count(self):
return len(self.comments.query.all())
@property
def author_name(self):
return self.author.name or ''
@property
def title(self):
return self.name.title()
@property
def excerpt(self):
return self.content[:self.excerpt_length]
class TestSuitStep(db.Model):
__tablename__ = 'test_suit_step'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
rank = db.Column(db.Integer, nullable=False, comment="执行顺序")
test_case_id = db.Column(db.Integer,
db.ForeignKey('test_case.id'),
nullable=False,
comment="用例")
skip = db.Column(db.Integer, nullable=False, comment="是否略过")
test_case_suit_id = db.Column(db.Integer,
db.ForeignKey('test_case_suit.id'),
comment="所属用例集ID")
input_args = db.Column(db.Text, comment="输入参数对象")
create_datetime = db.Column(db.DateTime,
server_default=db.text("CURRENT_TIMESTAMP"),
comment="创建时间")
update_datetime = db.Column(
db.DateTime,
nullable=False,
server_default=db.text(
"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
test_case = db.relationship('TestCase', backref=db.backref('suit'))
class Category(BaseMixin, db.Model):
__tablename__ = 'categories'
name = db.Column(db.String(100), unique=True)
description = db.Column(db.Text)
icon_id = db.Column(db.Integer,db.ForeignKey('font_icons.id'))
icon = db.relationship('FontIcon',backref='categories')
def __unicode__(self):
return self.name
@classmethod
def get_by_name(cls,name):
return cls.query.filter(cls.name==name).first()
class EsgRatingModel(db.Model):
__tablename__ = 'esg_rating'
data_provider_id = db.Column(db.String(2),
db.ForeignKey('data_provider.id'),
primary_key=True)
id = db.Column(db.String(5), primary_key=True)
@property
def serialize(self):
return {
'data_provider_id': self.data_provider_id,
'id': self.id,
}
class Interface(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
inf_url = db.Column(db.String(50), nullable=False)
inf_name = db.Column(db.String(10), nullable=False)
req_method = db.Column(db.String(10), nullable=False)
req_parameters = db.Column(db.String(150), nullable=False)
create_time = db.Column(db.DateTime, default=datetime.now)
create_person = db.Column(db.String(10), default='万海波')
project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=True)
__tablename__ = 'interface'
def __str__(self):
return self.inf_name
class Reference(db.Model):
__tablename__ = 'reference'
id = db.Column(db.Integer, primary_key=True)
id_charity = db.Column(db.Integer,
db.ForeignKey('charity.id'),
nullable=False,
unique=True)
id_support = db.Column(db.Integer,
db.ForeignKey('support.id'),
nullable=False,
unique=True)
id_about_service = db.Column(db.Integer,
db.ForeignKey('about_service.id'),
nullable=False,
unique=True)
charity = relationship("Charity", backref="charity")
support = relationship("Support", backref="support")
about_service = relationship("AboutService", backref="about_service")
def __init__(self, id_charity, id_support, id_about_service):
self.id_charity = id_charity
self.id_support = id_support
self.id_about_service = id_about_service
class TerminalInfo(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
boot_time = db.Column(db.Integer)
total_usage = db.Column(db.Integer)
free_usage = db.Column(db.Integer)
usage_percent = db.Column(db.Float)
total_memory = db.Column(db.Integer)
free_memory = db.Column(db.Integer)
memory_percent = db.Column(db.Float)
bytes_sent = db.Column(db.Integer)
bytes_recv = db.Column(db.Integer)
cpu_percent = db.Column(db.Float)
station_id = db.Column(db.Integer, db.ForeignKey('yjstationinfo.id'))
class Teacher(db.Model):
__tablename__ = 'teacher'
__bind_key__ = 'my_dom'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
status = db.Column(db.String(100), nullable=False)
created_time = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
update_time = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
school_id = db.Column(db.Integer, db.ForeignKey('school.id'))
class CompanyEsgFactorModel(db.Model):
__tablename__ = 'company_esg_factor'
company_id = db.Column(db.String(20),
db.ForeignKey('company.id'),
primary_key=True)
esg_factor_id = db.Column(db.Integer,
db.ForeignKey('esg_factor.id'),
primary_key=True)
date_key = db.Column(db.Date, primary_key=True)
score = db.Column(db.Float)
esg_factor = db.relationship('EsgFactorModel',
foreign_keys=[esg_factor_id])
@property
def serialize(self):
return {
'company_id': self.company_id,
'esg_factor_id': str(self.esg_factor_id),
'date_key': str(self.date_key),
'score': str(self.score),
}
class Symptom(db.Model):
__tablename__ = 'symptom'
# __table_args__ = {'schema': 'schema_any'}
# __abstract__ = True
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
date = db.Column(db.Date)
time = db.Column(db.Integer)
parts = db.Column(db.String(100))
degree = db.Column(db.Integer)
user_id = db.Column(db.ForeignKey('user.id'))
def __repr__(self):
return f"Symptom('{self.name}','{self.date}','{self.time}','{self.parts}', '{self.degree}')"
class PortfolioMetricDateModel(db.Model):
__tablename__ = 'portfolio_metric_date'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
portfolio_id = db.Column(db.Integer, db.ForeignKey('portfolio.id'), nullable=False)
date_key = db.Column(db.Date, nullable=False)
@property
def serialize(self):
return {
'id': str(self.id),
'portfolio_id': str(self.portfolio_id),
'date_key': str(self.date_key),
}
class PortfolioSecurityModel(db.Model):
__tablename__ = 'portfolio_security'
portfolio_id = db.Column(db.Integer,
db.ForeignKey('portfolio.id'),
primary_key=True)
security_id = db.Column(db.String(20),
db.ForeignKey('security.id'),
primary_key=True)
portfolio_update_date = db.Column(db.Date, primary_key=True)
position = db.Column(db.Float, nullable=False)
portfolio = db.relationship('PortfolioModel', foreign_keys=[portfolio_id])
security = db.relationship('SecurityModel', foreign_keys=[security_id])
@property
def serialize(self):
return {
'portfolio_id': str(self.portfolio_id),
'security_id': self.security_id,
'portfolio_update_date': str(self.portfolio_update_date),
'position': str(self.position),
}
class Comment(BaseMixin,db.Model):
__tablename__ = 'comments'
slug = db.Column(db.String(255),nullable=False,unique=True)
content = db.Column(db.Text,nullable=False)
author_id = db.Column(db.Integer,db.ForeignKey('users.id'))
author = db.relationship('User',backref=db.backref(
'comments',lazy="dynamic"))
article_id = db.Column(db.Integer,db.ForeignKey('articles.id'))
article = db.relationship('Article',backref=db.backref(
'comments',lazy='dynamic'))
post_id = db.Column(db.Integer,db.ForeignKey('posts.id'))
post = db.relationship('Post',backref=db.backref(
'comments',lazy='dynamic'))
def __init__(self,*args,**kwargs):
if kwargs.get('content',False):
self.content = kwargs.pop('content')
if kwargs.get('author_id',False):
self.author_id = kwargs.pop('author_id')
else:
self.author_id = None
if kwargs.get('article_id',False):
self.article_id = kwargs.pop('article_id')
else:
self.article_id = None
if kwargs.get('slug',False):
self.slug = kwargs.pop('slug')
else:
tmp = '/comments/'
if self.article_id is not None:
tmp += self.article_id + '/'
if self.author_id is not None:
tmp += self.author_id + '/'
self.slug = tmp
super(Comment,self).__init__(*args,**kwargs)
class DancingClassPerson(db.Model, TrackModifications):
__tablename__ = TABLE_DANCING_CLASS_PERSON
__table_args__ = (db.UniqueConstraint("dancing_class_id", "person_id", name="_dancing_class_person_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_PERSON}.id", ondelete="CASCADE"), nullable=False)
person = db.relationship("Person", lazy=False)
passed_triage = db.Column(db.Boolean, nullable=False, default=True)
notes = db.Column(db.String(256), nullable=True)
dancing_class_couples_leads = db.relationship("DancingClassCouple", foreign_keys="DancingClassCouple.person_id",
cascade="all, delete, delete-orphan", lazy=False)
dancing_class_couples_follows = db.relationship("DancingClassCouple", foreign_keys="DancingClassCouple.partner_id",
cascade="all, delete, delete-orphan", lazy=False)
def __repr__(self):
return f"{self.person} - {self.dancing_class}"
@property
def partners(self):
return [dcc.partner.person for dcc in self.dancing_class_couples_leads] + \
[dcc.person.person for dcc in self.dancing_class_couples_follows]
def json(self):
data = {
"id": self.id,
"person": {
"id": self.person.id,
},
"email": self.person.email,
"full_name": self.person.full_name,
"student_number": self.person.student_number,
"passed_triage": self.passed_triage,
"notes": self.notes,
}
return data
class VarAlarmInfo(db.Model):
__tablename__ = 'var_alarm_info'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
variable_id = db.Column(db.Integer, db.ForeignKey('yjvariableinfo.id'))
alarm_type = db.Column(db.Integer)
note = db.Column(db.String(128))
logs = db.relationship('VarAlarmLog',
backref='var_alarm_info',
lazy='dynamic',
cascade="delete, delete-orphan")
alarms = db.relationship('VarAlarm',
backref='var_alarm_info',
lazy='dynamic',
cascade="delete, delete-orphan")
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
title = db.Column(db.String(20), nullable=False)
body = db.Column(db.Text)
timestamp = db.Column(db.DateTime, default=datetime.now, index=True)
can_comment = db.Column(db.Boolean, default=True)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', back_populates='posts')
comments = db.relationship('Comment',
back_populates='post',
cascade='all,delete-orphan')
class Value(db.Model):
__tablename__ = 'values'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
variable_id = db.Column(db.Integer, db.ForeignKey('yjvariableinfo.id'))
value = db.Column(db.String(128))
time = db.Column(db.Integer)
def __init__(self, variable_id, value, time):
self.variable_id = variable_id
self.value = value
self.time = time
def __repr__(self):
return '<Value {} {} {} {}'.format(self.id, self.variable_id,
self.value, self.time)
class CourseInfo(db.Model):
__tablename__ = 'courseinfo'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.Text)
info = db.Column(db.Text)
extrainfo = db.Column(db.Text)
price = db.Column(db.Numeric)
teacherid = db.Column(db.Integer, db.ForeignKey('teacherinfo.id'))
# 订阅人数
buynum = db.Column(db.BigInteger)
favour = db.Column(db.Float)
# 课程总共能学多长时间
courselast = db.Column(db.BigInteger)
# 列表图片
mainimg = db.Column(db.Text)
