def get_subject_measurements(subject_uuid: SubjectId, database: Database):
"""Return all measurements for the subjects within the last 28 weeks."""
metric_uuids: List[MetricId] = metrics_of_subject(database, subject_uuid)
report_timestamp = datetime.fromisoformat(
report_date_time()) if report_date_time() != "" else datetime.now()
min_datetime = report_timestamp - timedelta(weeks=28)
min_iso_timestamp = min_datetime.isoformat()
return dict(measurements=list(
measurements_by_metric(database,
*metric_uuids,
min_iso_timestamp=min_iso_timestamp,
max_iso_timestamp=report_date_time())))
def test_missing_report_date_time(self):
"""Test that the report datetime is now if it's not present in the request."""
with patch("server_utilities.functions.bottle.request") as request:
request.query = {}
with patch("server_utilities.functions.datetime") as date_time:
date_time.now.return_value = self.now
self.assertEqual(self.expected_time_stamp, report_date_time())
def get_data_model(database: Database):
"""Return the data model."""
data_model = latest_datamodel(database, report_date_time())
if data_model:
md5 = md5_hash(data_model['timestamp'])
if "W/" + md5 == bottle.request.headers.get("If-None-Match"): # pylint: disable=no-member
bottle.abort(304) # Data model unchanged
bottle.response.set_header("ETag", md5)
return data_model
def get_reports(database: Database):
"""Return the quality reports."""
date_time = report_date_time()
data_model = latest_datamodel(database, date_time)
overview = latest_reports_overview(database, date_time)
overview["reports"] = []
recent_measurements = recent_measurements_by_metric_uuid(
database, date_time)
for report in latest_reports(database, date_time):
summarize_report(report, recent_measurements, data_model)
overview["reports"].append(report)
hide_credentials(data_model, *overview["reports"])
return overview
def get_report(database: Database, report_uuid: ReportId):
"""Return the quality report, including information about other reports needed for move/copy actions."""
date_time = report_date_time()
data_model = latest_datamodel(database, date_time)
reports = latest_reports(database, date_time)
for report in reports:
if report["report_uuid"] == report_uuid:
recent_measurements = recent_measurements_by_metric_uuid(
database, date_time)
summarize_report(report, recent_measurements, data_model)
break
hide_credentials(data_model, *reports)
return dict(reports=reports)
def get_tag_report(tag: str, database: Database):
"""Get a report with all metrics that have the specified tag."""
date_time = report_date_time()
reports = latest_reports(database, date_time)
data_model = latest_datamodel(database, date_time)
subjects = _get_subjects_and_metrics_by_tag(data_model, reports, tag)
tag_report = dict(title=f'Report for tag "{tag}"',
subtitle="Note: tag reports are read-only",
report_uuid=f"tag-{tag}",
timestamp=date_time,
subjects=subjects)
hide_credentials(data_model, tag_report)
summarize_report(tag_report,
recent_measurements_by_metric_uuid(database, date_time),
data_model)
return tag_report
def export_report_as_json(database: Database, report_uuid: ReportId):
"""Return the quality-time report, including iencrypted credentials for api access to the sources."""
date_time = report_date_time()
data_model = latest_datamodel(database, date_time)
report = latest_report(database, report_uuid)
# pylint doesn't seem to be able to see that bottle.request.query is dict(like) at runtime
if "public_key" in bottle.request.query: # pylint: disable=unsupported-membership-test
public_key = bottle.request.query["public_key"] # pylint: disable=unsubscriptable-object
else: # default to own public key
document = database.secrets.find_one({"name": EXPORT_FIELDS_KEYS_NAME},
{
"public_key": True,
"_id": False
})
public_key = document["public_key"]
try:
encrypt_credentials(data_model, public_key, report)
except TypeError:
bottle.response.status = 400
bottle.response.content_type = "application/json"
return json.dumps({"error": "Invalid public key."})
return report
def get_measurements(metric_uuid: MetricId, database: Database) -> dict:
"""Return the measurements for the metric."""
metric_uuid = cast(MetricId, metric_uuid.split("&")[0])
return dict(measurements=list(
measurements_by_metric(
database, metric_uuid, max_iso_timestamp=report_date_time())))
def test_report_date_time(self):
"""Test that the report datetime can be parsed from the HTTP request."""
with patch("server_utilities.functions.bottle.request") as request:
request.query = dict(report_date="2019-03-03T10:04:05Z")
self.assertEqual(self.expected_time_stamp, report_date_time())
def get_measurements(metric_uuid: MetricId, database: Database) -> Dict:
"""Return the measurements for the metric."""
metric_uuid = cast(MetricId, metric_uuid.split("&")[0])
return dict(measurements=list(
all_measurements(database, metric_uuid, report_date_time())))
def test_future_report_date_time(self, request):
"""Test that the report datetime is empty if it's a future date."""
request.query = dict(report_date="3000-01-01T00:00:00Z")
self.assertEqual("", report_date_time())
def test_missing_report_date_time(self, request):
"""Test that the report datetime is empty if it's not present in the request."""
request.query = {}
self.assertEqual("", report_date_time())
def test_report_date_time(self, request):
"""Test that the report datetime can be parsed from the HTTP request."""
request.query = dict(report_date="2019-03-03T10:04:05Z")
self.assertEqual(self.expected_time_stamp, report_date_time())