def deserialize(self, row: EntityRow) -> Favorite:
favorite = Favorite(connectedSpaceIds=row.get('connected_space_ids'),
dashboardIds=row.get('dashboard_ids'))
# noinspection PyTypeChecker
favorite: Favorite = UserBasedTupleShaper.deserialize(row, favorite)
# noinspection PyTypeChecker
favorite: Favorite = LastVisitShaper.deserialize(row, favorite)
return favorite
def serialize(self, favorite: Favorite) -> EntityRow:
row = {
'connected_space_ids': favorite.connectedSpaceIds,
'dashboard_ids': favorite.dashboardIds
}
row = UserBasedTupleShaper.serialize(favorite, row)
row = LastVisitShaper.serialize(favorite, row)
return row
def serialize(self, last_snapshot: LastSnapshot) -> EntityRow:
row = {
'language': last_snapshot.language,
'last_dashboard_id': last_snapshot.lastDashboardId,
'admin_dashboard_id': last_snapshot.adminDashboardId,
'favorite_pin': last_snapshot.favoritePin
}
row = UserBasedTupleShaper.serialize(last_snapshot, row)
row = LastVisitShaper.serialize(last_snapshot, row)
return row
def serialize(self, connected_space: ConnectedSpace) -> EntityRow:
row = {
'connect_id': connected_space.connectId,
'space_id': connected_space.spaceId,
'name': connected_space.name,
'is_template': connected_space.isTemplate
}
row = AuditableShaper.serialize(connected_space, row)
row = UserBasedTupleShaper.serialize(connected_space, row)
row = LastVisitShaper.serialize(connected_space, row)
return row
def serialize(self, subject: Subject) -> EntityRow:
row = {
'subject_id': subject.subjectId,
'name': subject.name,
'connect_id': subject.connectId,
'auto_refresh_interval': subject.autoRefreshInterval,
'dataset': SubjectShaper.serialize_dataset(subject.dataset)
}
row = AuditableShaper.serialize(subject, row)
row = UserBasedTupleShaper.serialize(subject, row)
row = LastVisitShaper.serialize(subject, row)
return row
def deserialize(self, row: EntityRow) -> ObjectiveAnalysis:
analysis = ObjectiveAnalysis(analysisId=row.get('analysis_id'),
title=row.get('title'),
description=row.get('description'),
perspectives=row.get('perspectives'))
# noinspection PyTypeChecker
analysis: ObjectiveAnalysis = UserBasedTupleShaper.deserialize(
row, analysis)
# noinspection PyTypeChecker
analysis: ObjectiveAnalysis = LastVisitShaper.deserialize(
row, analysis)
return analysis
def deserialize(self, row: EntityRow) -> Subject:
subject = Subject(subjectId=row.get('subject_id'),
name=row.get('name'),
connectId=row.get('connect_id'),
autoRefreshInterval=row.get('auto_refresh_interval'),
dataset=row.get('dataset'))
# noinspection PyTypeChecker
subject: Subject = AuditableShaper.deserialize(row, subject)
# noinspection PyTypeChecker
subject: Subject = UserBasedTupleShaper.deserialize(row, subject)
# noinspection PyTypeChecker
subject: Subject = LastVisitShaper.deserialize(row, subject)
return subject
def deserialize(self, row: EntityRow) -> LastSnapshot:
last_snapshot = LastSnapshot(
language=row.get('language'),
lastDashboardId=row.get('last_dashboard_id'),
adminDashboardId=row.get('admin_dashboard_id'),
favoritePin=row.get('favorite_pin'))
# noinspection PyTypeChecker
last_snapshot: LastSnapshot = UserBasedTupleShaper.deserialize(
row, last_snapshot)
# noinspection PyTypeChecker
last_snapshot: LastSnapshot = LastVisitShaper.deserialize(
row, last_snapshot)
return last_snapshot
def deserialize(self, row: EntityRow) -> Dashboard:
dashboard = Dashboard(
dashboardId=row.get('dashboard_id'),
name=row.get('name'),
reports=row.get('reports'),
paragraphs=row.get('paragraphs'),
autoRefreshInterval=row.get('auto_refresh_interval'))
# noinspection PyTypeChecker
dashboard: Dashboard = AuditableShaper.deserialize(row, dashboard)
# noinspection PyTypeChecker
dashboard: Dashboard = UserBasedTupleShaper.deserialize(row, dashboard)
# noinspection PyTypeChecker
dashboard: Dashboard = LastVisitShaper.deserialize(row, dashboard)
return dashboard
def serialize(self, analysis: ObjectiveAnalysis) -> EntityRow:
row = {
'analysis_id':
analysis.analysisId,
'title':
analysis.title,
'description':
analysis.description,
'perspectives':
ArrayHelper(
analysis.perspectives).map(lambda x: x.to_dict()).to_list()
}
row = UserBasedTupleShaper.serialize(analysis, row)
row = LastVisitShaper.serialize(analysis, row)
return row
def deserialize(self, row: EntityRow) -> ConnectedSpace:
connected_space = ConnectedSpace(connectId=row.get('connect_id'),
spaceId=row.get('space_id'),
name=row.get('name'),
isTemplate=row.get('is_template'))
# noinspection PyTypeChecker
connected_space: ConnectedSpace = AuditableShaper.deserialize(
row, connected_space)
# noinspection PyTypeChecker
connected_space: ConnectedSpace = UserBasedTupleShaper.deserialize(
row, connected_space)
# noinspection PyTypeChecker
connected_space: ConnectedSpace = LastVisitShaper.deserialize(
row, connected_space)
return connected_space
def serialize(self, dashboard: Dashboard) -> EntityRow:
row = {
'dashboard_id':
dashboard.dashboardId,
'name':
dashboard.name,
'reports':
ArrayHelper(dashboard.reports).map(
lambda x: self.serialize_to_dict(x)).to_list(),
'paragraphs':
ArrayHelper(dashboard.paragraphs).map(
lambda x: self.serialize_to_dict(x)).to_list(),
'auto_refresh_interval':
dashboard.autoRefreshInterval
}
row = AuditableShaper.serialize(dashboard, row)
row = UserBasedTupleShaper.serialize(dashboard, row)
row = LastVisitShaper.serialize(dashboard, row)
return row
def deserialize(self, row: EntityRow) -> Report:
report = Report(reportId=row.get('report_id'),
name=row.get('name'),
subjectId=row.get('subject_id'),
connectId=row.get('connect_id'),
filters=row.get('filters'),
funnels=row.get('funnels'),
indicators=row.get('indicators'),
dimensions=row.get('dimensions'),
description=row.get('description'),
rect=row.get('rect'),
chart=row.get('chart'),
simulating=row.get('simulating'),
simulateData=row.get('simulate_data'),
simulateThumbnail=row.get('simulate_thumbnail'))
# noinspection PyTypeChecker
report: Report = AuditableShaper.deserialize(row, report)
# noinspection PyTypeChecker
report: Report = UserBasedTupleShaper.deserialize(row, report)
# noinspection PyTypeChecker
report: Report = LastVisitShaper.deserialize(row, report)
return report
def serialize(self, report: Report) -> EntityRow:
row = {
'report_id':
report.reportId,
'name':
report.name,
'subject_id':
report.subjectId,
'connect_id':
report.connectId,
'filters':
self.serialize_to_dict(report.filters),
'funnels':
ArrayHelper(report.funnels).map(
lambda x: self.serialize_to_dict(x)).to_list(),
'indicators':
ArrayHelper(report.indicators).map(
lambda x: self.serialize_to_dict(x)).to_list(),
'dimensions':
ArrayHelper(report.dimensions).map(
lambda x: self.serialize_to_dict(x)).to_list(),
'description':
report.description,
'rect':
self.serialize_to_dict(report.rect),
'chart':
self.serialize_to_dict(report.chart),
'simulating':
False if report.simulating is None else report.simulating,
'simulate_data':
report.simulateData,
'simulate_thumbnail':
report.simulateThumbnail
}
row = AuditableShaper.serialize(report, row)
row = UserBasedTupleShaper.serialize(report, row)
row = LastVisitShaper.serialize(report, row)
return row