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 post_move_metric(metric_uuid: MetricId, target_subject_uuid: SubjectId, database: Database): """Move the metric to another subject.""" data_model = latest_datamodel(database) reports = latest_reports(database) source = MetricData(data_model, reports, metric_uuid) target = SubjectData(data_model, reports, target_subject_uuid) user = sessions.user(database) delta_description = f"{user['user']} moved the metric '{source.metric_name}' from subject " \ f"'{source.subject_name}' in report '{source.report_name}' to subject " \ f"'{target.subject_name}' in report '{target.report_name}'." target.subject["metrics"][metric_uuid] = source.metric reports_to_insert = [target.report] if target.report_uuid == source.report_uuid: # Metric is moved within the same report del target.report["subjects"][ source.subject_uuid]["metrics"][metric_uuid] target_uuids = [ target.report_uuid, source.subject_uuid, target_subject_uuid, metric_uuid ] else: # Metric is moved from one report to another, update both reports_to_insert.append(source.report) del source.subject["metrics"][metric_uuid] source.report["delta"] = dict( uuids=[source.report_uuid, source.subject_uuid, metric_uuid], email=user["email"], description=delta_description) target_uuids = [target.report_uuid, target_subject_uuid, metric_uuid] target.report["delta"] = dict(uuids=target_uuids, email=user["email"], description=delta_description) return insert_new_report(database, *reports_to_insert)
def post_metric_attribute(metric_uuid: MetricId, metric_attribute: str, database: Database): """Set the metric attribute.""" value = dict(bottle.request.json)[metric_attribute] data_model = latest_datamodel(database) reports = latest_reports(database) data = MetricData(data_model, reports, metric_uuid) if metric_attribute == "comment" and value: value = sanitize_html(value) old_value: Any if metric_attribute == "position": old_value, value = move_item(data, value, "metric") else: old_value = data.metric.get(metric_attribute) or "" if old_value == value: return dict(ok=True) # Nothing to do data.metric[metric_attribute] = value if metric_attribute == "type": data.metric.update(default_metric_attributes(database, value)) user = sessions.user(database) data.report["delta"] = dict( uuids=[data.report_uuid, data.subject_uuid, metric_uuid], email=user["email"], description= f"{user['user']} changed the {metric_attribute} of metric '{data.metric_name}' " f"of subject '{data.subject_name}' in report '{data.report_name}' from '{old_value}' to '{value}'." ) insert_new_report(database, data.report) attributes_impacting_status = ("accept_debt", "debt_target", "debt_end_date", "direction", "near_target", "target") if metric_attribute in attributes_impacting_status and ( latest := latest_measurement(database, metric_uuid)): return insert_new_measurement(database, data.datamodel, data.metric, latest)
def post_source_attribute(source_uuid: SourceId, source_attribute: str, database: Database): """Set a source attribute.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = SourceData(data_model, reports, source_uuid) value = dict(bottle.request.json)[source_attribute] old_value: Any if source_attribute == "position": old_value, value = move_item(data, value, "source") else: old_value = data.source.get(source_attribute) or "" data.source[source_attribute] = value if old_value == value: return dict(ok=True) # Nothing to do user = sessions.user(database) data.report["delta"] = dict( uuids=[ data.report_uuid, data.subject_uuid, data.metric_uuid, source_uuid ], email=user["email"], description= f"{user['user']} changed the {source_attribute} of source '{data.source_name}' " f"of metric '{data.metric_name}' of subject '{data.subject_name}' in report '{data.report_name}' " f"from '{old_value}' to '{value}'.") if source_attribute == "type": data.source["parameters"] = default_source_parameters( database, data.metric["type"], value) return insert_new_report(database, data.report)
def set_entity_attribute(metric_uuid: MetricId, source_uuid: SourceId, entity_key: str, attribute: str, database: Database) -> dict: """Set an entity attribute.""" data = SourceData(latest_datamodel(database), latest_reports(database), source_uuid) old_measurement = latest_measurement(database, metric_uuid) new_measurement = old_measurement.copy() source = [ s for s in new_measurement["sources"] if s["source_uuid"] == source_uuid ][0] entity = [e for e in source["entities"] if e["key"] == entity_key][0] entity_description = "/".join( [entity[key] for key in entity.keys() if key not in ("key", "url")]) old_value = source.get("entity_user_data", {}).get(entity_key, {}).get(attribute) or "" new_value = dict(bottle.request.json)[attribute] source.setdefault("entity_user_data", {}).setdefault(entity_key, {})[attribute] = new_value user = sessions.user(database) new_measurement["delta"] = dict( uuids=[data.report_uuid, data.subject_uuid, metric_uuid, source_uuid], description= f"{user['user']} changed the {attribute} of '{entity_description}' from '{old_value}' to " f"'{new_value}'.", email=user["email"], ) return insert_new_measurement(database, data.datamodel, data.metric, new_measurement, old_measurement)
def test_user(self, bottle_mock): """Test user function.""" bottle_mock.get_cookie = MagicMock(return_value=5) database = MagicMock() database.sessions = MagicMock() database.sessions.find_one = MagicMock(return_value={"user": "******"}) self.assertEqual('OK', sessions.user(database=database)["user"]) database.sessions.find_one.assert_called_with({'session_id': 5})
def delete_subject(subject_uuid: SubjectId, database: Database): """Delete the subject.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = SubjectData(data_model, reports, subject_uuid) del data.report["subjects"][subject_uuid] user = sessions.user(database) data.report["delta"] = dict( uuids=[data.report_uuid, subject_uuid], email=user["email"], description=f"{user['user']} deleted the subject '{data.subject_name}' from report '{data.report_name}'.") return insert_new_report(database, data.report)
def delete_report(report_uuid: ReportId, database: Database): """Delete a report.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = ReportData(data_model, reports, report_uuid) data.report["deleted"] = "true" user = sessions.user(database) data.report["delta"] = dict( uuids=[report_uuid], email=user["email"], description=f"{user['user']} deleted the report '{data.report_name}'.") return insert_new_report(database, data.report)
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 delete_metric(metric_uuid: MetricId, database: Database): """Delete a metric.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = MetricData(data_model, reports, metric_uuid) user = sessions.user(database) data.report["delta"] = dict( uuids=[data.report_uuid, data.subject_uuid, metric_uuid], email=user["email"], description= f"{user['user']} deleted metric '{data.metric_name}' from subject " f"'{data.subject_name}' in report '{data.report_name}'.") del data.subject["metrics"][metric_uuid] return insert_new_report(database, data.report)
def post_report_copy(report_uuid: ReportId, database: Database): """Copy a report.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = ReportData(data_model, reports, report_uuid) report_copy = copy_report(data.report, data.datamodel) user = sessions.user(database) report_copy["delta"] = dict( uuids=[report_uuid, report_copy["report_uuid"]], email=user["email"], description=f"{user['user']} copied the report '{data.report_name}'.") result = insert_new_report(database, report_copy) result["new_report_uuid"] = report_copy["report_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_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_reports_attribute(reports_attribute: str, database: Database): """Set a reports overview attribute.""" value = dict(bottle.request.json)[reports_attribute] overview = latest_reports_overview(database) old_value = overview.get(reports_attribute) if value == old_value: return dict(ok=True) # Nothing to do overview[reports_attribute] = value value_change_description = "" if reports_attribute == "layout" else f" from '{old_value}' to '{value}'" user = sessions.user(database) overview["delta"] = dict( email=user["email"], description= f"{user['user']} changed the {reports_attribute} of the reports overview" f"{value_change_description}.") return insert_new_reports_overview(database, overview)
def post_move_subject(subject_uuid: SubjectId, target_report_uuid: ReportId, database: Database): """Move the subject to another report.""" data_model = latest_datamodel(database) reports = latest_reports(database) source = SubjectData(data_model, reports, subject_uuid) target = ReportData(data_model, reports, target_report_uuid) target.report["subjects"][subject_uuid] = source.subject del source.report["subjects"][subject_uuid] user = sessions.user(database) delta_description = f"{user['user']} moved the subject '{source.subject_name}' from report " \ f"'{source.report_name}' to report '{target.report_name}'." source.report["delta"] = dict( uuids=[source.report_uuid, subject_uuid], email=user["email"], description=delta_description) target.report["delta"] = dict( uuids=[target_report_uuid, subject_uuid], email=user["email"], description=delta_description) return insert_new_report(database, source.report, target.report)
def delete_source(source_uuid: SourceId, database: Database): """Delete a source.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = SourceData(data_model, reports, source_uuid) user = sessions.user(database) data.report["delta"] = dict( uuids=[ data.report_uuid, data.subject_uuid, data.metric_uuid, source_uuid ], email=user["email"], description= f"{user['user']} deleted the source '{data.source_name}' from metric " f"'{data.metric_name}' of subject '{data.subject_name}' in report '{data.report_name}'." ) del data.metric["sources"][source_uuid] return insert_new_report(database, data.report)
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_report_attribute(report_uuid: ReportId, report_attribute: str, database: Database): """Set a report attribute.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = ReportData(data_model, reports, report_uuid) value = dict(bottle.request.json)[report_attribute] old_value = data.report.get(report_attribute) or "" data.report[report_attribute] = value value_change_description = "" if report_attribute == "layout" else f" from '{old_value}' to '{value}'" user = sessions.user(database) data.report["delta"] = dict( uuids=[report_uuid], email=user["email"], description= f"{user['user']} changed the {report_attribute} of report '{data.report_name}'" f"{value_change_description}.") return insert_new_report(database, data.report)
def post_subject_attribute(subject_uuid: SubjectId, subject_attribute: str, database: Database): """Set the subject attribute.""" data_model = latest_datamodel(database) reports = latest_reports(database) data = SubjectData(data_model, reports, subject_uuid) value = dict(bottle.request.json)[subject_attribute] old_value = data.subject.get(subject_attribute) or "" if subject_attribute == "position": old_value, value = move_item(data, value, "subject") else: data.subject[subject_attribute] = value if old_value == value: return dict(ok=True) # Nothing to do user = sessions.user(database) data.report["delta"] = dict( uuids=[data.report_uuid, subject_uuid], email=user["email"], description=f"{user['user']} changed the {subject_attribute} of subject " f"'{data.subject_name}' in report '{data.report_name}' from '{old_value}' to '{value}'.") return insert_new_report(database, data.report)
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) user = sessions.user(database) data.report["delta"] = dict( uuids=[data.report_uuid, data.subject_uuid, metric_uuid, source_uuid], email=user["email"], description= f"{user['user']} added a new source to metric '{data.metric_name}' of subject " f"'{data.subject_name}' in report '{data.report_name}'.") result = insert_new_report(database, data.report) result["new_source_uuid"] = source_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 post_move_source(source_uuid: SourceId, target_metric_uuid: MetricId, database: Database): """Move the source to another metric.""" data_model = latest_datamodel(database) reports = latest_reports(database) source = SourceData(data_model, reports, source_uuid) target = MetricData(data_model, reports, target_metric_uuid) user = sessions.user(database) delta_description = f"{user['user']} moved the source '{source.source_name}' from metric " \ f"'{source.metric_name}' of subject '{source.subject_name}' in report '{source.report_name}' " \ f"to metric '{target.metric_name}' of subject '{target.subject_name}' in report " \ f"'{target.report_name}'." target.metric["sources"][source_uuid] = source.source target_uuids: List[Union[Optional[ReportId], Optional[SubjectId], Optional[MetricId], Optional[SourceId]]] = \ [target.report_uuid] reports_to_insert = [target.report] if target.report_uuid == source.report_uuid: # Source is moved within the same report del target.report["subjects"][source.subject_uuid]["metrics"][ source.metric_uuid]["sources"][source_uuid] if target.subject_uuid != source.subject_uuid: # Source is moved from one subject to another subject, include both subject uuids in the delta target_uuids.append(source.subject_uuid) target_uuids.extend([target.subject_uuid, source.metric_uuid]) else: # Source is moved from one report to another, update both reports_to_insert.append(source.report) del source.metric["sources"][source_uuid] source.report["delta"] = dict(uuids=[ source.report_uuid, source.subject_uuid, source.metric_uuid, source_uuid ], email=user["email"], description=delta_description) target_uuids.append(target.subject_uuid) target.report["delta"] = dict(uuids=target_uuids + [target_metric_uuid, source_uuid], email=user["email"], description=delta_description) return insert_new_report(database, *reports_to_insert)
def post_source_parameter(source_uuid: SourceId, parameter_key: str, database: Database): """Set the source parameter.""" data = SourceData(latest_datamodel(database), latest_reports(database), source_uuid) new_value = new_parameter_value(data, parameter_key) old_value = data.source["parameters"].get(parameter_key) or "" if old_value == new_value: return dict(ok=True) # Nothing to do edit_scope = cast(EditScope, dict(bottle.request.json).get("edit_scope", "source")) changed_ids = change_source_parameter(data, parameter_key, old_value, new_value, edit_scope) if is_password_parameter(data.datamodel, data.source["type"], parameter_key): new_value, old_value = "*" * len(new_value), "*" * len(old_value) source_description = _source_description(data, edit_scope, parameter_key, old_value) user = sessions.user(database) delta = dict( uuids=changed_ids, email=user["email"], description= f"{user['user']} changed the {parameter_key} of {source_description} " f"from '{old_value}' to '{new_value}'.") reports_to_insert = [ report for report in data.reports if report["report_uuid"] in changed_ids ] for report in reports_to_insert: report["delta"] = delta result = insert_new_report(database, *reports_to_insert) if availability_checks := _availability_checks(data, parameter_key): result["availability"] = availability_checks
def test_user(self, bottle_mock): """Test user function.""" bottle_mock.get_cookie.return_value = 4 self.create_session() self.assertEqual("John", sessions.user(database=self.database)["user"]) self.database.sessions.find_one.assert_called_with({"session_id": 4})