def import_json_report(database: Database, imported_report):
""" Store the report given as json in the database. """
report_to_store = dict(title=imported_report.get("title",
"Example report"),
report_uuid=imported_report["report_uuid"],
subjects={})
for imported_subject in imported_report.get("subjects", []):
subject_to_store = default_subject_attributes(database,
imported_subject["type"])
subject_to_store["metrics"] = {} # Remove default metrics
subject_to_store["name"] = imported_subject["name"]
report_to_store["subjects"][uuid()] = subject_to_store
for imported_metric in imported_subject.get("metrics", []):
metric_to_store = default_metric_attributes(
database, imported_metric["type"])
metric_to_store.update(imported_metric)
metric_to_store["sources"] = {
} # Sources in the example report json are lists, we transform them to dicts
subject_to_store["metrics"][uuid()] = metric_to_store
for imported_source in imported_metric.get("sources", []):
source_to_store = metric_to_store["sources"][
uuid()] = imported_source
source_parameters = default_source_parameters(
database, imported_metric["type"], imported_source["type"])
for key, value in source_parameters.items():
if key not in source_to_store["parameters"]:
source_to_store["parameters"][key] = value
return insert_new_report(database, "{{user}} imported a new report",
(report_to_store, report_to_store["report_uuid"]))
def copy_report(report, data_model):
"""Return a copy of the report, its subjects, their metrics, and their sources."""
return copy_item(report,
report_uuid=uuid(),
title=f"{report['title']} (copy)",
subjects={
uuid(): copy_subject(subject,
data_model,
change_name=False)
for subject in report["subjects"].values()
})
def post_source_copy(source_uuid: SourceId, metric_uuid: MetricId,
database: Database):
"""Add a copy of the source to the metric (new in v3)."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
source = SourceData(data_model, reports, source_uuid)
target = MetricData(data_model, reports, metric_uuid)
target.metric["sources"][(source_copy_uuid :=
uuid())] = copy_source(source.source,
source.datamodel)
user = sessions.user(database)
target.report["delta"] = dict(
uuids=[
target.report_uuid, target.subject_uuid, target.metric_uuid,
source_copy_uuid
],
email=user["email"],
description=
f"{user['user']} copied the source '{source.source_name}' of metric "
f"'{source.metric_name}' of subject '{source.subject_name}' from report '{source.report_name}' to "
f"metric '{target.metric_name}' of subject '{target.subject_name}' in report "
f"'{target.report_name}'.")
result = insert_new_report(database, target.report)
result["new_source_uuid"] = source_copy_uuid
return result
def create_session(database: Database, username: str, email: str) -> None:
"""Generate a new random, secret and unique session id and a session expiration datetime and add it to the
database and the session cookie."""
session_id = cast(SessionId, uuid())
session_expiration_datetime = datetime.now() + timedelta(hours=24)
sessions.upsert(database, username, email, session_id, session_expiration_datetime)
set_session_cookie(session_id, session_expiration_datetime)
def post_metric_new(subject_uuid: SubjectId, database: Database):
"""Add a new metric."""
data = SubjectData(latest_datamodel(database), latest_reports(database), subject_uuid)
data.subject["metrics"][(metric_uuid := uuid())] = default_metric_attributes(database)
description = f"{{user}} added a new metric to subject '{data.subject_name}' in report '{data.report_name}'."
uuids = [data.report_uuid, data.subject_uuid, metric_uuid]
result = insert_new_report(database, description, (data.report, uuids))
result["new_metric_uuid"] = metric_uuid
return result
def post_report_new(database: Database):
"""Add a new report."""
report_uuid = uuid()
delta_description = "{user} created a new report."
report = dict(report_uuid=report_uuid, title="New report", subjects={})
result = insert_new_report(database, delta_description,
(report, [report_uuid]))
result["new_report_uuid"] = report_uuid
return result
def copy_metric(metric, data_model, change_name: bool = True):
"""Return a copy of the metric and its sources."""
kwargs: Dict[str, Any] = dict(
sources={
uuid(): copy_source(source, data_model, change_name=False)
for source in metric["sources"].values()
})
if change_name:
kwargs[
"name"] = f"{metric.get('name') or data_model['metrics'][metric['type']]['name']} (copy)"
return copy_item(metric, **kwargs)
def copy_subject(subject, data_model, change_name: bool = True):
"""Return a copy of the subject, its metrics, and their sources."""
kwargs: Dict[str, Any] = dict(
metrics={
uuid(): copy_metric(metric, data_model, change_name=False)
for metric in subject["metrics"].values()
})
if change_name:
kwargs[
"name"] = f"{subject.get('name') or data_model['subjects'][subject['type']]['name']} (copy)"
return copy_item(subject, **kwargs)
def post_new_subject(report_uuid: ReportId, database: Database):
"""Create a new subject."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
data = ReportData(data_model, reports, report_uuid)
data.report["subjects"][(subject_uuid := uuid())] = default_subject_attributes(database)
user = sessions.user(database)
data.report["delta"] = dict(
uuids=[report_uuid, subject_uuid], email=user["email"],
description=f"{user['user']} created a new subject in report '{data.report_name}'.")
result = insert_new_report(database, data.report)
result["new_subject_uuid"] = subject_uuid
return result
def post_new_subject(report_uuid: ReportId, database: Database):
"""Create a new subject."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
data = ReportData(data_model, reports, report_uuid)
data.report["subjects"][(subject_uuid :=
uuid())] = default_subject_attributes(database)
delta_description = f"{{user}} created a new subject in report '{data.report_name}'."
uuids = [report_uuid, subject_uuid]
result = insert_new_report(database, delta_description,
(data.report, uuids))
result["new_subject_uuid"] = subject_uuid
return result
def post_report_new(database: Database):
"""Add a new report."""
report_uuid = uuid()
user = sessions.user(database)
report = dict(report_uuid=report_uuid,
title="New report",
subjects={},
delta=dict(
uuids=[report_uuid],
email=user["email"],
description=f"{user['user']} created a new report."))
result = insert_new_report(database, report)
result["new_report_uuid"] = report_uuid
return result
def post_metric_copy(metric_uuid: MetricId, subject_uuid: SubjectId, database: Database):
"""Add a copy of the metric to the subject (new in v3)."""
data_model, reports = latest_datamodel(database), latest_reports(database)
source = MetricData(data_model, reports, metric_uuid)
target = SubjectData(data_model, reports, subject_uuid)
target.subject["metrics"][(metric_copy_uuid := uuid())] = copy_metric(source.metric, source.datamodel)
description = (
f"{{user}} copied the metric '{source.metric_name}' of subject '{source.subject_name}' from report "
f"'{source.report_name}' to subject '{target.subject_name}' in report '{target.report_name}'."
)
uuids = [target.report_uuid, target.subject_uuid, metric_copy_uuid]
result = insert_new_report(database, description, (target.report, uuids))
result["new_metric_uuid"] = metric_copy_uuid
return result
def post_subject_copy(subject_uuid: SubjectId, report_uuid: ReportId, database: Database):
"""Add a copy of the subject to the report (new in v3)."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
source = SubjectData(data_model, reports, subject_uuid)
target = ReportData(data_model, reports, report_uuid)
target.report["subjects"][(subject_copy_uuid := uuid())] = copy_subject(source.subject, source.datamodel)
user = sessions.user(database)
target.report["delta"] = dict(
uuids=[target.report_uuid, subject_copy_uuid], email=user["email"],
description=f"{user['user']} copied the subject '{source.subject_name}' from report " \
f"'{source.report_name}' to report '{target.report_name}'.")
result = insert_new_report(database, target.report)
result["new_subject_uuid"] = subject_copy_uuid
return result
def post_source_copy(source_uuid: SourceId, metric_uuid: MetricId, database: Database):
"""Add a copy of the source to the metric (new in v3)."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
source = SourceData(data_model, reports, source_uuid)
target = MetricData(data_model, reports, metric_uuid)
target.metric["sources"][(source_copy_uuid := uuid())] = copy_source(source.source, source.datamodel)
delta_description = (
f"{{user}} copied the source '{source.source_name}' of metric '{source.metric_name}' of subject "
f"'{source.subject_name}' from report '{source.report_name}' to metric '{target.metric_name}' of subject "
f"'{target.subject_name}' in report '{target.report_name}'."
)
uuids = [target.report_uuid, target.subject_uuid, target.metric_uuid, source_copy_uuid]
result = insert_new_report(database, delta_description, (target.report, uuids))
result["new_source_uuid"] = source_copy_uuid
return result
def post_source_new(metric_uuid: MetricId, database: Database):
"""Add a new source."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
data = MetricData(data_model, reports, metric_uuid)
metric_type = data.metric["type"]
source_type = data_model["metrics"][metric_type]["default_source"]
parameters = default_source_parameters(database, metric_type, source_type)
data.metric["sources"][(source_uuid := uuid())] = dict(type=source_type, parameters=parameters)
delta_description = (
f"{{user}} added a new source to metric '{data.metric_name}' of subject "
f"'{data.subject_name}' in report '{data.report_name}'."
)
uuids = [data.report_uuid, data.subject_uuid, metric_uuid, source_uuid]
result = insert_new_report(database, delta_description, (data.report, uuids))
result["new_source_uuid"] = source_uuid
return result
def post_metric_new(subject_uuid: SubjectId, database: Database):
"""Add a new metric."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
data = SubjectData(data_model, reports, subject_uuid)
data.subject["metrics"][(metric_uuid :=
uuid())] = default_metric_attributes(database)
user = sessions.user(database)
data.report["delta"] = dict(
uuids=[data.report_uuid, data.subject_uuid, metric_uuid],
email=user["email"],
description=
f"{user['user']} added a new metric to subject '{data.subject_name}' in report "
f"'{data.report_name}'.")
result = insert_new_report(database, data.report)
result["new_metric_uuid"] = metric_uuid
return result
def post_new_notification_destination(report_uuid: ReportId,
database: Database):
"""Create a new notification destination."""
data = ReportData(latest_datamodel(database), latest_reports(database),
report_uuid)
if "notification_destinations" not in data.report:
data.report["notification_destinations"] = {}
data.report["notification_destinations"][(
notification_destination_uuid :=
uuid())] = dict(webhook="",
name="Microsoft Teams webhook",
sleep_duration=0)
delta_description = f"{{user}} created a new destination for notifications in report '{data.report_name}'."
uuids = [report_uuid, notification_destination_uuid]
result = insert_new_report(database, delta_description,
(data.report, uuids))
result["new_destination_uuid"] = notification_destination_uuid
return result
def post_subject_copy(subject_uuid: SubjectId, report_uuid: ReportId,
database: Database):
"""Add a copy of the subject to the report (new in v3)."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
source = SubjectData(data_model, reports, subject_uuid)
target = ReportData(data_model, reports, report_uuid)
target.report["subjects"][(subject_copy_uuid :=
uuid())] = copy_subject(source.subject,
source.datamodel)
delta_description = (
f"{{user}} copied the subject '{source.subject_name}' from report "
f"'{source.report_name}' to report '{target.report_name}'.")
uuids = [target.report_uuid, subject_copy_uuid]
result = insert_new_report(database, delta_description,
(target.report, uuids))
result["new_subject_uuid"] = subject_copy_uuid
return result
def post_metric_copy(metric_uuid: MetricId, subject_uuid: SubjectId,
database: Database):
"""Add a copy of the metric to the subject (new in v3)."""
data_model = latest_datamodel(database)
reports = latest_reports(database)
source = MetricData(data_model, reports, metric_uuid)
target = SubjectData(data_model, reports, subject_uuid)
target.subject["metrics"][(metric_copy_uuid :=
uuid())] = copy_metric(source.metric,
source.datamodel)
user = sessions.user(database)
target.report["delta"] = dict(
uuids=[target.report_uuid, target.subject_uuid, metric_copy_uuid],
email=user["email"],
description=
f"{user['user']} copied the metric '{source.metric_name}' of subject "
f"'{source.subject_name}' from report '{source.report_name}' to subject '{target.subject_name}' "
f"in report '{target.report_name}'.")
result = insert_new_report(database, target.report)
result["new_metric_uuid"] = metric_copy_uuid
return result
def test_uuid(self):
"""Test the expected length of the uuid."""
self.assertEqual(36, len(uuid()))
