class Domain(Base):
__tablename__ = 'domain'
id = Column(Integer, primary_key=True)
domain = Column(String(100))
spider_name = Column(String(60))
article_num = Column(Integer())
created_ts = Column(TIMESTAMP())
updated_ts = Column(TIMESTAMP())
@staticmethod
def create(domain, spider_name, article_num=None):
now_date = datetime.datetime.utcnow()
record = session.query(Domain).\
filter_by(domain=domain).first()
if record is None:
record = Domain(domain=domain,
spider_name=spider_name,
article_num=article_num,
created_ts=now_date,
updated_ts=now_date)
else:
record.domain
record.spider_name = spider_name
record.article_num = article_num
record.updated_ts = now_date
session.add(record)
session.commit()
return record
class UserTable(Base):
"""
# 用户 id、用户名、年龄、生日、性别、学历、字段创建时间、字段更新时间
"""
__tablename__ = 'user'
uid = Column(BigInteger(), primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer())
birthday = Column(Date())
gender = Column(CHAR(10))
education = Column(String(50))
create_time = Column(TIMESTAMP(3), default=get_time())
update_time = Column(TIMESTAMP(3), onupdate=get_time(), default=get_time())
def __repr__(self):
return "<User(uid:{}, " \
"name:{}, " \
"age:{}, " \
"birthday:{}, " \
"gender:{}, " \
"education:{}, " \
"create_time:{}, " \
"update_time:{})>".format(self.uid,
self.name,
self.age,
self.birthday,
self.gender,
self.education,
self.create_time,
self.update_time)
def get_sqlalchemy_col(column_name: str, column_type_name: str,
primary_key_col_name: str) -> Column:
"""
Helper method that returns the sqlalchemy Column object to be used for Table def.
"""
if column_type_name == "timestamp without time zone":
col = Column(column_name, TIMESTAMP(timezone=False))
elif column_type_name == "timestamp with time zone":
col = Column(column_name, TIMESTAMP(timezone=True))
elif column_type_name == "date":
col = Column(column_name, Date)
elif column_type_name == "real":
col = Column(column_name, REAL)
elif column_type_name == "integer":
col = Column(column_name, Integer)
elif column_type_name == "smallint":
col = Column(column_name, SMALLINT)
elif column_type_name == "text":
col = Column(column_name, TEXT)
elif column_type_name == "bigint":
col = Column(column_name, BIGINT)
elif column_type_name == "float":
col = Column(column_name, Float)
elif column_type_name == "boolean":
col = Column(column_name, Boolean)
elif column_type_name == "json":
col = Column(column_name, JSON)
else:
col = Column(column_name, String)
if column_name == primary_key_col_name:
col.primary_key = True
return col
class IoTDevice(DeclarativeBase, SQLSourceMixin):
__tablename__ = 'device.iot'
device_id = Column(String(15), primary_key=True)
name = Column(String(63), )
desc = Column(String(127), )
type = Column(String(31), )
lat = Column(Double, )
lon = Column(Double, )
alt = Column(Double, )
reference = Column(Boolean, )
display = Column(Boolean, )
device_type = Column(String(15), )
owner_id = Column(String(31), )
mobile = Column(Boolean, )
outdoor = Column(Boolean, )
manufacturer_id = Column(String(31), )
mac_id = Column(String(31), )
devstat = Column(String(31), )
sb_id = Column(String(31), )
mb_id = Column(String(31), )
errorcode = Column(String(63), )
area = Column(String(31), )
areatype = Column(String(31), )
sensors = Column(JSON)
_created_at = Column(TIMESTAMP(), server_default=func.now())
_updated_at = Column(
TIMESTAMP(),
server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"))
class Trip(Base):
__tablename__ = "trip"
pk = Column(Integer, primary_key=True)
id = Column(String)
route_pk = Column(Integer, ForeignKey("route.pk"), nullable=False)
source_pk = Column(
Integer, ForeignKey("feed_update.pk"), index=True, nullable=False
)
direction_id = Column(Boolean)
started_at = Column(TIMESTAMP(timezone=True))
updated_at = Column(TIMESTAMP(timezone=True))
delay = Column(Integer)
# Stop times are considered in the past if their stop sequence is less than
# the trip's current stop sequence
current_stop_sequence = Column(Integer) # TODO: make non-nullable
source = relationship("FeedUpdate", cascade="none")
route = relationship("Route", back_populates="trips", cascade="none")
vehicle = relationship(
"Vehicle", back_populates="trip", cascade="none", uselist=False, lazy="joined"
)
stop_times = relationship(
"TripStopTime",
back_populates="trip",
order_by="TripStopTime.stop_sequence",
cascade="all, delete-orphan",
cascade_backrefs=False,
)
alerts = relationship(
"Alert", secondary="alert_trip", back_populates="trips", cascade="all"
)
__table_args__ = (UniqueConstraint(route_pk, id),)
class SystemUpdate(Base):
__tablename__ = "system_update"
pk = Column(Integer, primary_key=True)
system_pk = Column(Integer, ForeignKey("system.pk"))
class Status(enum.Enum):
SCHEDULED = 1
IN_PROGRESS = 2
SUCCESS = 3
FAILED = 4
status = Column(Enum(Status, native_enum=False), nullable=False)
status_message = Column(String) # TODO: rename stack trace?
total_duration = Column(Float)
scheduled_at = Column(TIMESTAMP(timezone=True),
default=datetime.datetime.utcnow)
completed_at = Column(TIMESTAMP(timezone=True))
config = Column(String)
config_template = Column(String)
config_parameters = Column(String)
config_source_url = Column(String)
transiter_version = Column(String)
system = relationship("System", back_populates="updates")
__table_args__ = (Index("system_update_system_pk_system_update_pk_idx",
system_pk, pk), )
class AbstractRecord(metaclass=ABCMeta):
"""
Abstract Record
"""
created_at = Column(TIMESTAMP(), nullable=False)
updated_at = Column(TIMESTAMP(), nullable=False)
def dict(self, aFilter=utils.defaultFilter):
"""
Create a dictionnary representing the current object by filtering the object __dict__
:param aFilter: predicate used on the __dict__ keys to filter the dictionnary
:return: a dictionnary
"""
# TODO: test 'blob' wValue
wDict = self.__dict__
wDateTypes = (datetime.date, datetime.datetime)
wExported = {}
for wKey, wValue in wDict.items():
if (aFilter(wKey)):
# If the value is an AbstractRecord
if issubclass(wValue.__class__, AbstractRecord):
wExported[wKey] = wValue.dict(aFilter)
# If the value is a Date
elif issubclass(wValue.__class__, wDateTypes):
# Make a real timestamp
wExported[wKey] = int(time.mktime(wValue.timetuple()))
# Otherwise
else:
wExported[wKey] = wValue
return wExported
class FacetTimeFrame(BaseModel):
"""Implements the FacetTimeFrame model.
A timeframe is used to set the scope for the facet. This information
is used when automatically generatae queries and other helper functions.
"""
start_time = Column(TIMESTAMP(timezone=True))
end_time = Column(TIMESTAMP(timezone=True))
description = Column(UnicodeText())
user_id = Column(Integer, ForeignKey("user.id"))
facet_id = Column(Integer, ForeignKey("facet.id"))
def __init__(self,
start_time,
end_time,
facet,
user=None,
description=None):
"""Initialize the InvestigationTimeFrame object.
Args:
start_time (datetime): Timezone-aware UTC datetime object.
end_time (datetime): Timezone-aware UTC datetime object.
facet (Facet): Facet for this time frame
description (str): Description of the timeframe (optional)
"""
super().__init__()
self.start_time = start_time
self.end_time = end_time
self.facet = facet
self.user = user
self.description = description
class PresDetails(Base):
"""
处方明细(药材)表类
"""
__tablename__ = 'dyf_prescriptions_details'
prescription_details_id = Column(String(36),
primary_key=True,
nullable=False,
comment='处方详情ID')
prescri_id = Column(String(36), nullable=False, comment='处方ID')
medicines = Column(String(100), nullable=False, comment='药品名')
goods_num = Column(String(100), comment='药材编号')
dose = Column(String(10), server_default='0.00', comment='剂量')
unit = Column(String(50), nullable=False, comment='单位')
m_usage = Column(String(100), comment='药品特殊煎法')
status = Column(Integer, server_default='0', comment='状态')
type = Column(Integer, server_default='0', comment='药材类型：0 中药，1西药')
goods_norms = Column(String(100), comment='药品规格')
goods_orgin = Column(String(100), comment='药品产地')
remark = Column(String(100), comment='备注')
dose_that = Column(String(100), comment='药品注意事项说明')
company_num = Column(String(50), comment='机构编号')
unit_price = Column(Float, server_default='0.00', comment='医院药品销售单价')
MedPerDos = Column(String(20), comment='用量(剂量)eg:2片/次(每次两片)')
MedPerDay = Column(String(20), comment='执行频率(频次)（eg:一日3次）')
create_time = Column(TIMESTAMP(timezone=False),
server_default=func.now(),
comment='创建时间')
updata_time = Column(TIMESTAMP(timezone=False),
nullable=False,
comment='数据更新时间')
class CustomerRegister(Base):
__tablename__ = 'customer_register'
id = Column(Integer, primary_key=True)
insert_time = Column(TIMESTAMP(True))
update_time = Column(TIMESTAMP(True))
operator_id = Column(Integer)
delete_flag = Column(Integer)
organ_id = Column(Integer)
net_id = Column(Integer)
organ_user_id = Column(Integer)
saleman_id = Column(Integer)
register_phone = Column(String(20))
register_code = Column(String(20))
register_time = Column(TIMESTAMP(True))
product_code = Column(String(50))
province = Column(String(50))
city = Column(String(50))
result = Column(Integer)
saleman_name = Column(String(20))
saleman_phone = Column(String(20))
customer_source = Column(String(100))
def __str__(self):
return self.register_code + ':' + self.register_phone + '(' + str(self.register_time) + '):' + self.province + self.city
class CustomerApply(Base):
__tablename__ = 'customer_apply'
id = Column(Integer, primary_key=True)
insert_time = Column(TIMESTAMP(True))
update_time = Column(TIMESTAMP(True))
operator_id = Column(Integer)
delete_flag = Column(Integer)
apply_id = Column(String(20))
apply_time = Column(TIMESTAMP(True))
customer_register_code = Column(String(20))
register_time = Column(TIMESTAMP(True))
organ_id = Column(Integer)
net_id = Column(Integer)
organ_user_id = Column(Integer)
register_phone = Column(String(20))
product_code = Column(String(20))
product_name = Column(String(20))
province = Column(String(50))
city = Column(String(50))
act_pid = Column(String(64))
def __str__(self):
return self.apply_id + ':' + self.customer_register_code + ', ' + str(self.organ_id) + ', ' + str(self.net_id) + ', ' + str(self.organ_user_id) + ', ' + self.register_phone\
+ ', ' + self.product_name + '(' + self.product_code + '), at: ' + self.province + self.city
class BasicInfo(Base):
__tablename__ = 'customer_application_info_pre'
id = Column(Integer, primary_key=True)
insert_time = Column(TIMESTAMP(True))
update_time = Column(TIMESTAMP(True))
operator_id = Column(Integer)
delete_flag = Column(Integer)
customer_apply_id = Column(String(20))
customer_apply_time = Column(TIMESTAMP(True))
loan_use = Column(String(100))
loan_use_descr = Column(String(300))
loan_use_self_descr = Column(String(500))
apply_amount = Column(String(100))
education = Column(String(100))
marriage = Column(String(100))
support_num = Column(String(100))
income = Column(String(100))
living_type = Column(String(100))
employment_type = Column(String(100))
transportation = Column(String(100))
loan_use_child = Column(String(100))
province = Column(String(100))
city = Column(String(100))
districts = Column(String(100))
street = Column(String(100))
def __str__(self):
return self.customer_apply_id + ':' + self.loan_use + '>' + self.loan_use_descr + '>' + self.loan_use_self_descr + ':' + self.apply_amount + ', ' + self.education + ', ' + self.marriage + ', ' + self.support_num \
+ ', ' + self.income + ', ' + self.living_type + ', ' + self.employment_type + ', ' + self.transportation + ', ' + self.loan_use_child + ', ' + self.province + self.city + self.districts + self.street
class Product(Base, MetaMixin):
__tablename__ = 'products'
__table_args__ = {"mysql_charset": "utf8"}
query = db_session.query_property(ProductQuery)
id = Column(Integer, primary_key=True, autoincrement=True)
category_id = Column(INTEGER(unsigned=True), ForeignKey('categories.id'))
internal_name = Column(String(64), unique=True)
market_name = Column(String(64))
part_a = Column(String(64), nullable=True)
part_b = Column(String(64), nullable=True)
ab_ratio = Column(String(16), nullable=True)
color = Column(String(32), nullable=True)
spec = Column(String(32), nullable=True)
label_viscosity = Column(String(32), nullable=True)
viscosity_width = Column(String(32), nullable=True)
created_at = Column(TIMESTAMP(True),
nullable=True,
server_default=text('CURRENT_TIMESTAMP'))
updated_at = Column(TIMESTAMP(True), nullable=True)
category = relationship("Category",
back_populates="products",
lazy='joined')
def to_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class AuditMixin(object):
"""Server side created_at and updated_at utc table audit column mixin.
Notes
-----
- The stored procedure should be created prior to table creation.
pgawedge.triggers.UPDATE_AT_DDL_STATEMENT contains ddl statement.
- configure_mappers() should be called prior to table creation.
"""
created_at = Column(
TIMESTAMP(timezone=True), server_default=utcnow(), nullable=False
)
updated_at = Column(
TIMESTAMP(timezone=True), server_default=utcnow(),
server_onupdate=FetchedValue(for_update=True), nullable=False
)
@classmethod
def __declare_first__(cls):
table = getattr(cls, '__table__', None)
if table is not None:
event.listen(
table, 'after_create', CreateUpdateAtTrigger(table.fullname)
)
event.listen(
table, 'before_drop', DropUpdateAtTrigger(table.fullname)
)
class Notifications(Base):
__tablename__ = 'notifications'
id_notifications = Column(Integer,
Sequence('notifications_id_notifications_seq'),
primary_key=True)
address = Column(String, nullable=False)
# matchingrule = Column(String, nullable=False)
id_matchingrule = Column(Integer)
modifytime = Column(TIMESTAMP(True))
currcontent = Column(String)
coloredcurrcontent = Column(String)
currdocslinks = Column(String)
detectedreplacedorinserted = Column(String)
oldcontenttime = Column(TIMESTAMP(True))
oldcontent = Column(String)
coloredoldcontent = Column(String)
olddocslinks = Column(String)
detecteddeleted = Column(String)
changes = Column(String, nullable=False)
recipients = Column(ARRAY(String))
ackers = Column(
ARRAY(String)
) # It's an array in case of future use. Normally should have maximum 1 element
def __repr__(self):
return "<Notification(id_notifications='%s', address='%s', matchingrule='%s', id_matchingrule='%s'," \
" modifytime='%s', oldcontent='%s', changes='%s' recipients='%s', ackers='%s')>" % \
(self.id_notifications, self.address, self.matchingrule, self.id_matchingrule, self.modifytime,
self.oldcontent, self.changes, self.recipients, self.ackers)
class Order(Base):
"""
订单表类
"""
__tablename__ = 'dyf_order'
order_id = Column(String(36),
nullable=False,
primary_key=True,
comment='订单id')
create_time = Column(TIMESTAMP(timezone=False),
server_default=func.now(),
comment='订单创建时间')
source_id = Column(Integer, nullable=False, comment='订单来源 机构编码')
order_time = Column(String(25), comment='处方生成时间')
treat_card = Column(String(50), comment='诊疗卡号')
reg_num = Column(String(50), nullable=False, comment='挂单号')
addr_str = Column(String(120), nullable=False, comment='收货地址')
provinces = Column(String(10), comment='省份')
city = Column(String(10), comment='城市')
zone = Column(String(10), comment='区')
consignee = Column(String(20), nullable=False, comment='收货人')
con_tel = Column(String(50), nullable=False, comment='收货人电话')
send_goods_time = Column(String(25), comment='送货时间')
storagetype = Column(Integer, comment='仓库')
is_hos_addr = Column(Integer,
nullable=False,
comment='是否送医院 0 未知, 1 送医院,2 送病人家里')
updata_time = Column(TIMESTAMP(timezone=False),
nullable=False,
comment='数据更新时间')
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
twitch_user_id = Column(String(50))
twitch_user_name = Column(String(50))
messages_sent = Column(Integer, nullable=False, default=0)
number_of_logins = Column(Integer, nullable=False, default=1)
last_visit = Column(TIMESTAMP(timezone=False),
nullable=False,
server_default=text("NOW()"))
loyalty_points = Column(Integer, nullable=False, default=0)
eggs = Column(Integer, nullable=False, default=0)
egg_lock = Column(TIMESTAMP(timezone=False),
nullable=False,
server_default=text("NOW()"))
warnings = Column(Integer, nullable=False, default=0)
lost_counter = Column(Integer, nullable=False, default=0)
stream_badges = Column(String(50), nullable=False, default="Tueftlie")
hen_name = Column(String(50))
smart_counter = Column(Integer, nullable=False, default=0)
honor_counter = Column(Integer, nullable=False, default=0)
name_pronunciation = Column(String(50))
shoutout_text = Column(String(500))
# Relationships
raids = relationship('Raid', backref='user')
class Alert(Base):
__tablename__ = "alert"
pk = Column(Integer, primary_key=True)
id = Column(String)
source_pk = Column(
Integer, ForeignKey("feed_update.pk"), index=True, nullable=False
)
system_pk = Column(Integer, ForeignKey("system.pk"), index=True)
Cause = parse.Alert.Cause
Effect = parse.Alert.Effect
cause: Cause = Column(
Enum(Cause, native_enum=False), nullable=False, default=Cause.UNKNOWN_CAUSE
)
effect: Effect = Column(
Enum(Effect, native_enum=False), nullable=False, default=Effect.UNKNOWN_EFFECT
)
sort_order = Column(Integer, default=-1)
created_at = Column(TIMESTAMP(timezone=True))
updated_at = Column(TIMESTAMP(timezone=True))
messages: list = relationship(
"AlertMessage", back_populates="alert", cascade="all, delete-orphan"
)
active_periods: list = relationship(
"AlertActivePeriod", back_populates="alert", cascade="all, delete-orphan"
)
system = relationship("System", back_populates="alerts", cascade="none")
source = relationship("FeedUpdate", cascade="none")
agencies = relationship(
"Agency", secondary="alert_agency", back_populates="alerts", cascade="none",
)
routes = relationship(
"Route", secondary="alert_route", back_populates="alerts", cascade="none",
)
stops = relationship(
"Stop", secondary="alert_stop", back_populates="alerts", cascade="none",
)
trips = relationship(
"Trip", secondary="alert_trip", back_populates="alerts", cascade="none",
)
__table_args__ = (UniqueConstraint("system_pk", "id"),)
@staticmethod
def from_parsed_alert(alert: parse.Alert) -> "Alert":
return Alert(
id=alert.id,
cause=alert.cause,
effect=alert.effect,
created_at=alert.created_at,
updated_at=alert.updated_at,
sort_order=alert.sort_order,
messages=list(map(AlertMessage.from_parsed_message, alert.messages)),
active_periods=list(
map(AlertActivePeriod.from_parsed_active_period, alert.active_periods)
),
)
class CloseshiftModel(db.Model):
__tablename__ = "closeshift"
id = Column(BigInteger, primary_key=True)
created_at = Column(
TIMESTAMP(timezone="UTC"), default=datetime.utcnow
)
company_inn = Column(String)
company_name = Column(String)
operator = Column(String)
close_datetime = Column(TIMESTAMP(timezone="UTC"))
shiftnumber = Column(Integer)
receiptsquantity = Column(SmallInteger)
documentsquantity = Column(SmallInteger)
nottransmitteddocumentsquantity = Column(BigInteger)
nottransmitteddocumentsdatetime = Column(
TIMESTAMP(timezone="UTC")
)
ofdresponsetimeoutsign = Column(
TIMESTAMP(timezone="UTC")
)
fiscaldrivereplacerequiredsign = Column(BigInteger)
kktregid = Column(String)
fiscaldrivenumber = Column(String)
fiscaldocumentnumber = Column(BigInteger)
fiscalsign = Column(Integer)
__table_args__ = (
UniqueConstraint(
"fiscaldrivenumber",
"fiscalsign",
"fiscaldocumentnumber",
name="_closeshift_uniq",
),
)
class Connected_user(Base):
"""
This table is for checking the currently online clients, my intial goal was to have theese in a memory database like
mnesia, however right now they are on disk...
"""
__tablename__ = 'connected_users'
username = Column(VARCHAR(66), primary_key=True)
connection_date = Column(TIMESTAMP(0), server_default=func.now())
last_ping = Column(TIMESTAMP(0), server_default=func.now())
def __init__(self, username):
self.username = username
def update_last_ping(self, last_ping):
"""
Updates the last ping of the user
:param last_ping:
:return:
"""
self.last_ping = last_ping
def clear_table(self):
"""
Clears the whole table, its for booting up and stuff.
:return:
"""
pass
class IoTEvent(DeclarativeBase, SQLSourceMixin):
__tablename__ = 'result.iot.event'
__table_args__ = (UniqueConstraint("start_time", "area"), {
"mysql_engine": "RocksDB",
})
uid = Column(Integer, autoincrement=True, primary_key=True)
event_id = Column(String(20, collation="utf8_bin"), index=True)
area = Column(String(16, collation='utf8_bin'), )
start_time = Column(DateTime)
end_time = Column(DateTime)
duration = Column(Integer)
event_count = Column(Integer)
max_value = Column(Double, )
device_count = Column(Integer)
first_device = Column(String(15), )
first_value = Column(Double, )
item = Column(String(15), )
score = Column(Integer, )
level = Column(SmallInteger, )
min_lat = Column(Double, )
min_lon = Column(Double, )
max_lat = Column(Double, )
max_lon = Column(Double, )
device_list = Column(JSON)
_created_at = Column(TIMESTAMP(), server_default=func.now())
_updated_at = Column(
TIMESTAMP(),
server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"))
class Event(Base):
"""A single event"""
__tablename__ = "events"
id = Column(Integer, primary_key=True, nullable=False)
event_type = Column(String(50), nullable=False)
event_ts = Column(TIMESTAMP(True), nullable=False)
event_id = Column(String(36), nullable=False)
aggregate_id = Column(String(36), nullable=False)
kafka_ts = Column(TIMESTAMP(timezone=True), nullable=False)
json_data = Column(JSON(none_as_null=False), nullable=True)
def __init__(self,
event_type: str,
event_ts: dt.datetime,
event_id: str,
aggregate_id: str,
kafka_ts: dt.datetime,
json_data: Optional[Dict] = None):
self.event_type = event_type
self.event_ts = event_ts
self.event_id = event_id
self.aggregate_id = aggregate_id
self.kafka_ts = kafka_ts
self.json_data = json_data
def __repr__(self) -> str:
return f'<Event {self.event_type}, {self.event_id}>'
class IoTRawDataCount(DeclarativeBase, SQLSourceMixin):
__tablename__ = 'rawdata.iot.count'
__table_args__ = (PrimaryKeyConstraint("date", "device_id"), {
"mysql_engine": "RocksDB",
})
date = Column(Date, )
device_id = Column(String(15, collation='utf8_bin'), )
ampere = Column(SmallInteger, )
co = Column(SmallInteger, )
devstat = Column(SmallInteger, )
humidity = Column(SmallInteger, )
humidity_main = Column(SmallInteger, )
no2 = Column(SmallInteger, )
noise = Column(SmallInteger, )
o3 = Column(SmallInteger, )
pm1 = Column(SmallInteger, )
pm2_5 = Column(SmallInteger, )
pm10 = Column(SmallInteger, )
temperature = Column(SmallInteger, )
temperature_main = Column(SmallInteger, )
voc = Column(SmallInteger, )
volt = Column(SmallInteger, )
_created_at = Column(TIMESTAMP(), server_default=func.now())
_updated_at = Column(
TIMESTAMP(),
server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"))
class Order(Base):
"""A single orders"""
__tablename__ = "orders"
id = Column(Integer, primary_key=True, nullable=False)
order_id = Column(String(36), nullable=False)
customer_id = Column(String(36), nullable=False)
product = Column(String(191), nullable=False)
status = Column(String(36), nullable=False)
created_ts = Column(TIMESTAMP(timezone=True), nullable=False)
updated_ts = Column(TIMESTAMP(timezone=True), nullable=False)
def __init__(
self,
order_id: str,
customer_id: str,
product: str,
status: str,
created_ts: dt.datetime,
updated_ts: dt.datetime,
):
self.order_id = order_id
self.customer_id = customer_id
self.product = product
self.status = status
self.created_ts = created_ts
self.updated_ts = updated_ts
def __repr__(self) -> str:
return f'<Order {self.order_id}>'
class Image(Base):
__tablename__ = 'images'
id = Column(Integer, primary_key=True)
use_type = Column(Integer, nullable=False)
alt = Column(VARCHAR(length=120), nullable=False, default='')
caption = Column(VARCHAR(length=255), nullable=False, default='')
filename = Column(VARCHAR(length=300), nullable=False)
width = Column(Integer)
height = Column(Integer)
filesize = Column(Integer)
digest = Column(VARCHAR(length=32))
status = Column(Integer, nullable=False, default=1)
deleted_flg = Column(BOOLEAN, nullable=False, default=False)
created_at = Column(TIMESTAMP(timezone=True),
nullable=False,
server_default=func.now())
updated_at = Column(TIMESTAMP(timezone=True),
nullable=False,
server_default=func.now(),
onupdate=func.now())
@validates('use_type')
def validate_use_type(self, key, use_type):
use_type_ints = list(map(int, ImageUseType))
if use_type not in use_type_ints:
raise ValueError('Unsupported use_type.')
return use_type
class CombinationTradeInfoModel(BaseModel):
__tablename__ = 'combination_trade_info'
combination = Column(VARCHAR(128), primary_key=True)
trade_pair_id = Column(VARCHAR(64), primary_key=True)
market = Column(VARCHAR(64), primary_key=True)
order_id = Column(BIGINT, nullable=True, default=None)
order_time = Column(TIMESTAMP(3), nullable=True)
state = Column(VARCHAR(64), nullable=False)
symbol = Column(VARCHAR(32), nullable=False)
trade_side = Column(VARCHAR(32), nullable=False)
trade_target = Column(VARCHAR(64), nullable=True)
create_time = Column(TIMESTAMP(3), nullable=False)
query_amount = Column(DECIMAL(30, 10), nullable=False)
query_price = Column(DECIMAL(30, 10), nullable=False)
depth = Column(Text, nullable=True)
depth_time = Column(TIMESTAMP(3), nullable=False)
filled_amount = Column(DECIMAL(30, 10), nullable=True)
filled_fees = Column(DECIMAL(30, 10), nullable=True) # 手续费
exception_message = Column(Text, nullable=True)
def add(self):
session = get_dbsession()
try:
session.add(self)
session.commit()
except:
session.rollback()
raise
class UsageModel(Base):
__tablename__ = 'usage_table'
id = Column('id', Integer, primary_key=True)
user_org_group_id = Column('user_org_group_id',
Integer,
ForeignKey('user_org_group.id'),
nullable=False)
usage_type = Column('usage_type', VARCHAR(225), nullable=False)
status = Column('status', VARCHAR(225), nullable=False)
usage_value = Column('usage_value', Integer, nullable=False)
start_time = Column('start_time', TIMESTAMP(timezone=True))
end_time = Column('end_time', TIMESTAMP(timezone=True))
created_at = Column('created_at',
TIMESTAMP(timezone=True),
nullable=False,
server_default=func.current_timestamp())
payment_mode = Column('payment_mode', VARCHAR(225))
group_id = Column('group_id', VARCHAR(225))
registry_address_key = Column('registry_address_key', VARCHAR(225))
ethereum_json_rpc_endpoint = Column('ethereum_json_rpc_endpoint',
VARCHAR(225))
response_time = Column('response_time', FLOAT)
response_code = Column('response_code', VARCHAR(225))
error_message = Column('error_message', VARCHAR(225))
version = Column('version', VARCHAR(225))
client_type = Column('client_type', VARCHAR(225))
user_details = Column('user_details', VARCHAR(225))
channel_id = Column('channel_id', VARCHAR(225))
operation = Column('operation', VARCHAR(225))
user_address = Column('user_address', VARCHAR(225))
user_name = Column('username', VARCHAR(225))
org_id = Column('org_id', VARCHAR(225))
service_id = Column('service_id', VARCHAR(225))
resource = Column('resource', VARCHAR(225))
request_id = Column('request_id', VARCHAR(225))
class Device(Base):
__tablename__ = 'devices'
id = Column(Integer(), primary_key=True)
type = Column(String(length=255), nullable=False)
address = Column(String(length=255), nullable=False)
identifier = Column(String(length=255), nullable=False, unique=True)
token = Column(String(length=255), nullable=False)
enabled = Column(Boolean(), default=True)
last_seen = Column(TIMESTAMP(), nullable=False, default=datetime.utcnow)
updated = Column(TIMESTAMP(),
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
added = Column(TIMESTAMP(), nullable=False, default=datetime.utcnow)
@staticmethod
def check_if_exists(db: Session, item: 'Device') -> bool:
return db.query(Device).filter(
Device.identifier == item.identifier).scalar() is not None
@staticmethod
def find(db: Session, identifier: str) -> Optional['Device']:
return db.query(Device).filter(
Device.identifier == identifier).scalar()
@staticmethod
def new_from_device_info(identifier: str,
device_info: miio.discovery.Device) -> 'Device':
return Device(type=device_info.__class__.__name__,
address='{}:{}'.format(device_info.ip, device_info.port),
identifier=identifier,
token=codecs.encode(device_info.token, 'hex'))
class StripePrice(StripeBase):
__tablename__ = "stripe_price"
stripe_id = Column(String(255), nullable=False, primary_key=True)
stripe_product_id = Column(String(255), nullable=False)
stripe_created = Column(DateTime(timezone=True), nullable=False)
active = Column(Boolean, nullable=False, default=True)
currency = Column(String(3), nullable=False)
recurring_interval = Column(String(5), nullable=True)
recurring_interval_count = Column(Integer, nullable=True)
unit_amount = Column(Integer, nullable=True)
create_timestamp = Column(TIMESTAMP(timezone=True),
nullable=False,
server_default=now())
update_timestamp = Column(
TIMESTAMP(timezone=True),
nullable=False,
server_default=now(),
server_onupdate=now(),
)
invoice_line_items = relationship("StripeInvoiceLineItem",
back_populates="price",
uselist=True)
subscription_items = relationship("StripeSubscriptionItem",
back_populates="price",
uselist=True)
def get_email_id(self) -> None:
"""Prices can be related to multiple Customers, so return None."""
return None
class Domain(Base):
__tablename__ = 'domain'
id = Column(Integer, primary_key=True)
domain = Column(String(100))
spider_name = Column(String(60))
article_num = Column(Integer())
created_ts = Column(TIMESTAMP())
updated_ts = Column(TIMESTAMP())
@staticmethod
def get_all():
data = session.query(Domain).all()
return [item.serialize for item in data]
@property
def serialize(self):
"""
docs: http://stackoverflow.com/questions/7102754/jsonify-a-sqlalchemy-result-set-in-flask
:return:
"""
return {
'domain': self.domain,
'article_num': self.article_num,
'created_ts': str(self.created_ts),
'updated_ts': str(self.updated_ts)
}
