def serialize(self, indicator: Indicator) -> EntityRow:
return TupleShaper.serialize_tenant_based(
indicator, {
'indicator_id':
indicator.indicatorId,
'name':
indicator.name,
'topic_or_subject_id':
indicator.topicOrSubjectId,
'factor_id':
indicator.factorId,
'base_on':
indicator.baseOn,
'category_1':
indicator.category1,
'category_2':
indicator.category2,
'category_3':
indicator.category3,
'value_buckets':
indicator.valueBuckets,
'relevants':
ArrayHelper(
indicator.relevants).map(lambda x: x.to_dict()).to_list(),
'group_ids':
indicator.groupIds,
'filter':
IndicatorShaper.serialize_filter(indicator.filter),
'description':
indicator.description,
})
def deserialize(self, row: EntityRow) -> Enum:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
Enum(enumId=row.get('enum_id'),
name=row.get('name'),
description=row.get('description'),
parentEnumId=row.get('parent_enum_id')))
def serialize(self, an_enum: Enum) -> EntityRow:
return TupleShaper.serialize_tenant_based(
an_enum, {
'enum_id': an_enum.enumId,
'name': an_enum.name,
'description': an_enum.description,
'parent_enum_id': an_enum.parentEnumId
})
def deserialize(self, row: EntityRow) -> ExternalWriter:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
ExternalWriter(writerId=row.get('writer_id'),
writerCode=row.get('writer_code'),
type=row.get('type'),
pat=row.get('pat'),
url=row.get('url')))
def serialize(self, external_writer: ExternalWriter) -> EntityRow:
return TupleShaper.serialize_tenant_based(
external_writer, {
'writer_id': external_writer.writerId,
'writer_code': external_writer.writerCode,
'type': external_writer.type,
'pat': external_writer.pat,
'url': external_writer.url
})
def serialize(self, user_group: UserGroup) -> EntityRow:
return TupleShaper.serialize_tenant_based(
user_group, {
'user_group_id': user_group.userGroupId,
'name': user_group.name,
'description': user_group.description,
'user_ids': user_group.userIds,
'space_ids': user_group.spaceIds,
'indicator_ids': user_group.indicatorIds
})
def deserialize(self, row: EntityRow) -> UserGroup:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
UserGroup(userGroupId=row.get('user_group_id'),
name=row.get('name'),
description=row.get('description'),
userIds=row.get('user_ids'),
spaceIds=row.get('space_ids'),
indicatorIds=row.get('indicator_ids')))
def serialize(self, catalog: Catalog) -> EntityRow:
return TupleShaper.serialize_tenant_based(catalog, {
'catalog_id': catalog.catalogId,
'name': catalog.name,
'topic_ids': catalog.topicIds,
'tech_owner_id': catalog.techOwnerId,
'biz_owner_id': catalog.bizOwnerId,
'tags': catalog.tags,
'description': catalog.description
})
def serialize(self, user: User) -> EntityRow:
return TupleShaper.serialize_tenant_based(user, {
'user_id': user.userId,
'name': user.name,
'nickname': user.nickName,
'password': user.password,
'is_active': user.isActive,
'group_ids': user.groupIds,
'role': user.role,
})
def serialize(self, space: Space) -> EntityRow:
return TupleShaper.serialize_tenant_based(
space, {
'space_id': space.spaceId,
'name': space.name,
'description': space.description,
'topic_ids': space.topicIds,
'group_ids': space.groupIds,
'filters': SpaceShaper.serialize_filters(space.filters),
})
def deserialize(self, row: EntityRow) -> Space:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
Space(spaceId=row.get('space_id'),
name=row.get('name'),
description=row.get('description'),
topicIds=row.get('topic_ids'),
groupIds=row.get('group_ids'),
filters=row.get('filters')))
def deserialize(self, row: EntityRow) -> Catalog:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(row, Catalog(
catalogId=row.get('catalog_id'),
name=row.get('name'),
topicIds=row.get('topic_ids'),
techOwnerId=row.get('tech_owner_id'),
bizOwnerId=row.get('biz_owner_id'),
tags=row.get('tags'),
description=row.get('description')
))
def deserialize(self, row: EntityRow) -> User:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(row, User(
userId=row.get('user_id'),
name=row.get('name'),
nickName=row.get('nickname'),
password=row.get('password'),
isActive=row.get('is_active'),
groupIds=row.get('group_ids'),
role=row.get('role')
))
def deserialize(self, row: EntityRow) -> Topic:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
Topic(topicId=row.get('topic_id'),
name=row.get('name'),
description=row.get('description'),
type=row.get('type'),
kind=row.get('kind'),
dataSourceId=row.get('data_source_id'),
factors=row.get('factors')))
def deserialize(self, row: EntityRow) -> MonitorRule:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
MonitorRule(ruleId=row.get('rule_id'),
code=row.get('code'),
grade=row.get('grade'),
severity=row.get('severity'),
topicId=row.get('topic_id'),
factorId=row.get('factor_id'),
params=row.get('params'),
enabled=row.get('enabled')))
def serialize(self, pipeline: Pipeline) -> EntityRow:
return TupleShaper.serialize_tenant_based(pipeline, {
'pipeline_id': pipeline.pipelineId,
'topic_id': pipeline.topicId,
'name': pipeline.name,
'type': pipeline.type,
'prerequisite_enabled': pipeline.conditional,
'prerequisite_on': PipelineShaper.serialize_prerequisite_on(pipeline.on),
'stages': PipelineShaper.serialize_stages(pipeline.stages),
'enabled': pipeline.enabled,
'validated': pipeline.validated
})
def deserialize(self, row: EntityRow) -> Pipeline:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(row, Pipeline(
pipelineId=row.get('pipeline_id'),
topicId=row.get('topic_id'),
name=row.get('name'),
type=row.get('type'),
conditional=row.get('prerequisite_enabled'),
on=row.get('prerequisite_on'),
stages=row.get('stages'),
enabled=row.get('enabled'),
validated=row.get('validated')
))
def serialize(self, data_source: DataSource) -> EntityRow:
return TupleShaper.serialize_tenant_based(
data_source, {
'data_source_id': data_source.dataSourceId,
'data_source_code': data_source.dataSourceCode,
'data_source_type': data_source.dataSourceType,
'host': data_source.host,
'port': data_source.port,
'username': data_source.username,
'password': data_source.password,
'name': data_source.name,
'url': data_source.url,
'params': DataSourceShaper.serialize_params(data_source.params)
})
def deserialize(self, row: EntityRow) -> DataSource:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
DataSource(dataSourceId=row.get('data_source_id'),
dataSourceCode=row.get('data_source_code'),
dataSourceType=row.get('data_source_type'),
host=row.get('host'),
port=row.get('port'),
username=row.get('username'),
password=row.get('password'),
name=row.get('name'),
url=row.get('url'),
params=row.get('params')))
def deserialize(self, row: EntityRow) -> Bucket:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
self.to_derived_bucket(
Bucket(
bucketId=row.get('bucket_id'),
name=row.get('name'),
type=row.get('type'),
include=row.get('include'),
measure=row.get('measure'),
enumId=row.get('enum_id'),
segments=row.get('segments'),
description=row.get('description'),
)))
def serialize(self, topic: Topic) -> EntityRow:
return TupleShaper.serialize_tenant_based(
topic, {
'topic_id':
topic.topicId,
'name':
topic.name,
'description':
topic.description,
'type':
topic.type,
'kind':
topic.kind,
'data_source_id':
topic.dataSourceId,
'factors':
ArrayHelper(topic.factors).map(lambda x: x.dict()).to_list(),
})
def deserialize(self, row: EntityRow) -> Indicator:
# noinspection PyTypeChecker
return TupleShaper.deserialize_tenant_based(
row,
Indicator(
indicatorId=row.get('indicator_id'),
name=row.get('name'),
topicOrSubjectId=row.get('topic_or_subject_id'),
factorId=row.get('factor_id'),
baseOn=row.get('base_on'),
category1=row.get('category_1'),
category2=row.get('category_2'),
category3=row.get('category_3'),
valueBuckets=row.get('value_buckets'),
relevants=row.get('relevants'),
groupIds=row.get('group_ids'),
filter=row.get('filter'),
description=row.get('description'),
))
def serialize(self, bucket: Bucket) -> EntityRow:
return TupleShaper.serialize_tenant_based(
bucket, {
'bucket_id':
bucket.bucketId,
'name':
bucket.name,
'type':
bucket.type,
'include':
self.try_get_include(bucket),
'measure':
self.try_get_measure(bucket),
'enum_id':
self.try_get_enum_id(bucket),
'segments':
ArrayHelper(
bucket.segments).map(lambda x: x.to_dict()).to_list(),
'description':
bucket.description,
})
def serialize(self, monitor_rule: MonitorRule) -> EntityRow:
return TupleShaper.serialize_tenant_based(
monitor_rule, {
'rule_id':
monitor_rule.ruleId,
'code':
monitor_rule.code,
'grade':
monitor_rule.grade,
'severity':
monitor_rule.severity,
'topic_id':
monitor_rule.topicId,
'factor_id':
monitor_rule.factorId,
'params':
monitor_rule.params.to_dict()
if monitor_rule.params is not None else None,
'enabled':
monitor_rule.enabled
})
def serialize(self, tenant: Tenant) -> EntityRow:
return TupleShaper.serialize(tenant, {
'tenant_id': tenant.tenantId,
'name': tenant.name
})
def deserialize(self, row: EntityRow) -> Tenant:
# noinspection PyTypeChecker
return TupleShaper.deserialize(
row, Tenant(tenantId=row.get('tenant_id'), name=row.get('name')))
