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())