Add measurement processing workflow

ag_data/admin.py

@@ -1,12 +1,6 @@
 from django.contrib import admin  # noqa f401
 
-from .models import (
-    AGVenue,
-    AGEvent,
-    AGSensorType,
-    AGSensor,
-    AGMeasurement,
-)
+from .models import AGVenue, AGEvent, AGSensorType, AGSensor, AGMeasurement
 
 admin.site.register(AGVenue)
 admin.site.register(AGEvent)

ag_data/formulas/ingestion_engine.py

@@ -0,0 +1,33 @@
+from ag_data import models
+from ag_data.formulas.library.system import mercury_formulas as hgFormulas
+
+
+class MeasurementIngestionEngine:
+
+    processingFormulas = {
+        0: hgFormulas.fEmptyResult,
+        2: hgFormulas.fMercurySimpleTemperatureSensor,
+        4: hgFormulas.fMercuryDualTemperatureSensor,
+        6: hgFormulas.fMercuryFlowSensor,
+    }
+
+    def saveMeasurement(self, measurementDict, event):
+        timestamp = measurementDict["measurement_timestamp"]
+        sensor_id = measurementDict["measurement_sensor"]
+        rawValue = measurementDict["measurement_values"]
+
+        sensor = models.AGSensor.objects.get(pk=sensor_id)
+        sensor_type = sensor.type_id
+        processing_formula = sensor_type.processing_formula
+
+        formula = MeasurementIngestionEngine.processingFormulas.get(
+            processing_formula, hgFormulas.fEmptyResult
+        )
+
+        value = {"reading": rawValue}
+
+        value["result"] = formula(timestamp, sensor, rawValue)
+
+        return models.AGMeasurement.objects.create(
+            timestamp=timestamp, event_uuid=event, sensor_id=sensor, value=value
+        )

ag_data/formulas/library/system/mercury_formulas.py

@@ -0,0 +1,48 @@
+#
+# Formulas for Mercury's built-in and natively supported sensor types
+# Sample processing formulas with primary sensors and fictional Mercury-branded sensors
+#
+
+from ag_data import models
+
+
+def fEmptyResult(timestamp, sensor, payload):
+
+    return {}
+
+
+def fMercurySimpleTemperatureSensor(timestamp, sensor, payload):
+
+    # This Simple Temperature Sensor decides it wants its own formula, even though it does
+    # nothing more than the fEmptyResult function.
+
+    return {}
+
+
+def fMercuryDualTemperatureSensor(timestamp, sensor, payload):
+    mean = payload["internal"] / 2 + payload["external"] / 2
+    diff = payload["internal"] - payload["external"]
+
+    return {"mean": mean, "diff": diff}
+
+
+def fMercuryFlowSensor(timestamp, sensor, payload):
+    result = {}
+
+    measurements = models.AGMeasurement.objects.filter(sensor_id=sensor.id)
+
+    if measurements.count() == 0:
+        result = {"gasLevel": 100}
+    else:
+        latest = measurements.latest("timestamp")
+        timeElapsed = timestamp - latest.timestamp
+
+        lastResult = latest.value["result"]["gasLevel"]
+
+        if lastResult is not None:
+            result = {
+                "gasLevel": lastResult
+                - payload["volumetricFlow"] * (timeElapsed.microseconds / 1000000)
+            }
+
+    return result

ag_data/formulas/library/usr/alice_formulas.py

@@ -0,0 +1,4 @@
+#
+# Alice's Formulas for example sensor types
+#
+#

ag_data/formulas/library/usr/bob_formulas.py

@@ -0,0 +1,4 @@
+#
+# Bob's Formulas for example sensor types
+#
+#

ag_data/presets/built_in_content.py

@@ -0,0 +1,52 @@
+built_in_sensor_types = [
+    {
+        "agSensorTypeID": 0,
+        "agSensorTypeName": "Coin Side Sensor",
+        "agSensorTypeFormula": 0,
+        "agSensorTypeFormat": {
+            "reading": {"side": {"unit": "", "format": "bool"}, "result": {}}
+        },
+    },
+    {
+        "agSensorTypeID": 2,
+        "agSensorTypeName": "Simple Temperature Sensor",
+        "agSensorTypeFormula": 2,
+        "agSensorTypeFormat": {
+            "reading": {"reading": {"unit": "Celsius", "format": "float"}},
+            "result": {},
+        },
+    },
+    {
+        "agSensorTypeID": 4,
+        "agSensorTypeName": "Dual Temperature Sensor",
+        "agSensorTypeFormula": 4,
+        "agSensorTypeFormat": {
+            "reading": {
+                "internal": {"unit": "Keivin", "format": "float"},
+                "external": {"unit": "Keivin", "format": "float"},
+            },
+            "result": {
+                "mean": {"unit": "Keivin", "format": "float"},
+                "diff": {"unit": "Keivin", "format": "float"},
+            },
+        },
+    },
+    {
+        "agSensorTypeID": 6,
+        "agSensorTypeName": "Gas Flow Sensor",
+        "agSensorTypeFormula": 6,
+        "agSensorTypeFormat": {
+            "reading": {"volumetricFlow": {"unit": "cc/sec", "format": "float"}},
+            "result": {"gasLevel": {"unit": "%", "format": "float"}},
+        },
+    },
+    {
+        "agSensorTypeID": 8,
+        "agSensorTypeName": "Gaussian Random Number Emitter",
+        "agSensorTypeFormula": 0,
+        "agSensorTypeFormat": {
+            "reading": {"sample": {"unit": "", "format": "float"}},
+            "result": {},
+        },
+    },
+]

ag_data/presets/helpers.py

@@ -0,0 +1,104 @@
+from ag_data import models
+from ag_data.presets import sample_user_data
+from ag_data import utilities
+
+
+def createVenueFromPresetAtIndex(index):
+    """Create a venue from available presets of venues
+
+    Arguments:
+
+        index {int} -- the index of the sensor preset to use.
+
+    Raises:
+
+        Exception: an exception raises when the index is not valid in presets.
+    """
+
+    if index > len(sample_user_data.sample_venues) - 1:
+        raise Exception(
+            "Cannot find requested venue (index " + str(index) + ") from presets"
+        )
+    else:
+        pass
+
+    preset = sample_user_data.sample_venues[index]
+
+    venue = models.AGVenue.objects.create(
+        name=preset["agVenueName"],
+        description=preset["agVenueDescription"],
+        latitude=preset["agVenueLatitude"],
+        longitude=preset["agVenueLongitude"],
+    )
+
+    return venue
+
+
+def createEventFromPresetAtIndex(venue, index):
+    """Create an event from available presets of events
+
+    Arguments:
+
+        index {int} -- the index of the sensor preset to use.
+
+    Raises:
+
+        Exception: an exception raises when the index is not valid in presets.
+
+        Assertion: an assertion error raises when there is no venue prior to the
+        creation of the event.
+    """
+
+    if index > len(sample_user_data.sample_events) - 1:
+        raise Exception(
+            "Cannot find requested event (index " + str(index) + ") from presets"
+        )
+    else:
+        pass
+
+    preset = sample_user_data.sample_events[index]
+
+    utilities.assertVenue(venue)
+
+    event = models.AGEvent.objects.create(
+        name=preset["agEventName"],
+        date=preset["agEventDate"],
+        description=preset["agEventDescription"],
+        venue_uuid=venue,
+    )
+
+    return event
+
+
+def createSensorFromPresetAtIndex(index):
+    """Create a sensor from available presets of sensors
+
+    Arguments:
+
+        index {int} -- the index of the sensor preset to use.
+
+        cascadeCreation {bool=False} -- whether or not to create a corresponding sensor
+        type which the chosen sensor preset needs (default: {False})
+
+    Raises:
+
+        Exception: an exception raises when the index is not valid in presets.
+    """
+
+    if index > len(sample_user_data.sample_sensors) - 1:
+        raise Exception(
+            "Cannot find requested sensor (index " + str(index) + ") from presets"
+        )
+    else:
+        pass
+
+    preset = sample_user_data.sample_sensors[index]
+
+    sensorType = models.AGSensorType.objects.get(pk=preset["agSensorType"])
+    utilities.assertSensorType(sensorType)
+
+    sensor = models.AGSensor.objects.create(
+        name=preset["agSensorName"], type_id=sensorType
+    )
+
+    return sensor

ag_data/presets.py → ag_data/presets/sample_user_data.py

@@ -1,4 +1,4 @@
-venue_presets = [
+sample_venues = [
     {
         "agVenueName": "Washington Square Park",
         "agVenueDescription": "Sunnyside Daycare's Butterfly Room.",
@@ -13,7 +13,7 @@
     },
 ]
 
-event_presets = [
+sample_events = [
     {
         "agEventName": "Sunny Day Test Drive",
         "agEventDate": "2020-02-02T20:21:22",
@@ -28,25 +28,10 @@
     },
 ]
 
-sensor_type_presets = [
-    {
-        "agSensorTypeID": 0,
-        "agSensorTypeName": "Simple Temperature Sensor",
-        "agSensorTypeFormula": 0,
-        "agSensorTypeFormat": {"reading": {"unit": "Celsius", "format": "float"}},
-    },
-    {
-        "agSensorTypeID": 1,
-        "agSensorTypeName": "Dual Temperature Sensor",
-        "agSensorTypeFormula": 0,
-        "agSensorTypeFormat": {
-            "internal": {"unit": "Keivin", "format": "float"},
-            "external": {"unit": "Keivin", "format": "float"},
-        },
-    },
-]
-
-sensor_presets = [
-    {"agSensorName": "Sample Simple Temperature", "agSensorType": 0},
-    {"agSensorName": "Sample Dual Temperature", "agSensorType": 1},
+sample_sensors = [
+    {"agSensorName": "Sample Simple Temperature", "agSensorType": 2},
+    {"agSensorName": "Sample Dual Temperature", "agSensorType": 4},
+    {"agSensorName": "Sample Gas Tank Flow", "agSensorType": 6},
+    {"agSensorName": "Sample Coin Side", "agSensorType": 0},
+    {"agSensorName": "Sample Gaussian Value", "agSensorType": 8},
 ]