adds support for automated observations and care authn. (#21)

Co-authored-by: Aakash Singh <mail@singhaakash.dev>

Author: rithviknishad

common/authentication.py

@@ -48,7 +48,6 @@ class CareAuthentication(JWTAuthentication):
     token provided in a request header.
     """
 
-    facility_header = "X-Facility-Id"
     auth_header_type = "Care_Bearer"
     auth_header_type_bytes = auth_header_type.encode(HTTP_HEADER_ENCODING)
 
@@ -82,7 +81,7 @@ def authenticate(self, request):
         if raw_token is None:
             return None
 
-        open_id_url = settings.CARE_JWK_URL
+        open_id_url = f"{settings.CARE_API}/api/gateway_device/jwks.json/"
         validated_token = self.get_validated_token(open_id_url, raw_token)
 
         return self.get_user(validated_token), validated_token

core/settings.py

@@ -205,12 +205,9 @@
 CELERY_BROKER_URL = env("CELERY_BROKER_URL", default=REDIS_URL)
 
 # Configs
-CARE_URL = env("CARE_URL")
 CARE_API = env("CARE_API")
-FACILITY_ID = env("FACILITY_ID")
-CARE_JWK_URL = env("CARE_JWK_URL")
-CARE_VERIFY_TOKEN_URL = env("CARE_VERIFY_TOKEN_URL")
-
+CARE_API_TIMEOUT = env.int("CARE_API_TIMEOUT", default=25)
+GATEWAY_DEVICE_ID = env("GATEWAY_DEVICE_ID")
 
 JWKS = JsonWebKey.import_key_set(
     json.loads(base64.b64decode(env("JWKS_BASE64", default=generate_encoded_jwks())))
@@ -225,7 +222,7 @@
 
 # Observations
 REDIS_OBSERVATIONS_KEY = "observations"
-UPDATE_INTERVAL = env.int("UPDATE_INTERVAL", default=60)
+AUTOMATED_OBSERVATIONS_INTERVAL = env.int("AUTOMATED_OBSERVATIONS_INTERVAL", default=60)
 
 
 # Cameras

core/urls.py

@@ -32,7 +32,7 @@
     path("admin/", admin.site.urls),
     path("", home, name="home"),
     path("", include(router.urls)),
-    path(".well-known/openid-configuration/", PublicJWKsView.as_view()),
+    path("openid-configuration/", PublicJWKsView.as_view()),
     path("", include("middleware.observation.urls")),
     path("", include("middleware.camera.urls")),
     path("", include("middleware.stream.urls")),

docker-compose.yaml

@@ -6,14 +6,10 @@ services:
       - ./.env
     volumes:
       - postgres-data:/var/lib/postgresql/data
-    ports:
-      - "5432:5432"
 
   redis:
     image: redis:7.2
     restart: unless-stopped
-    ports:
-      - "6379:6379"
 
   # rtsptoweb:
   stream-server:
@@ -24,7 +20,6 @@ services:
     ports:
       - "8080:8080"
 
-
   # teleicu-middleware
   teleicu-middleware:
     restart: unless-stopped

middleware/care_client.py

@@ -0,0 +1,116 @@
+import json
+import logging
+
+import requests
+from django.conf import settings
+from django.http import HttpResponse
+from rest_framework import status
+from rest_framework.exceptions import APIException
+
+from middleware.utils import generate_jwt
+
+logger = logging.getLogger(__name__)
+
+
+class CareClient:
+    auth_header_type = "Gateway_Bearer"
+
+    def __init__(self):
+        self.base_url = settings.CARE_API
+        self.timeout = settings.CARE_API_TIMEOUT
+
+    def _get_url(self, endpoint):
+        return f"{self.base_url}{endpoint}"
+
+    def _get_headers(self):
+        return {
+            "Authorization": f"{self.auth_header_type} {generate_jwt()}",
+            "X-Gateway-Id": settings.GATEWAY_DEVICE_ID,
+            "Accept": "application/json",
+        }
+
+    def _make_request(
+        self, method: str, url: str, as_http_response=False, **request_kwargs
+    ) -> HttpResponse | dict:
+        """
+        Execute the HTTP request and validate the response.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            url: Full URL to request
+            as_http_response: If True, return HttpResponse object instead of JSON
+            **request_kwargs: Additional arguments to pass to requests method
+
+        Returns:
+            HttpResponse or dict depending on as_http_response flag
+
+        Raises:
+            APIException: For all request failures with appropriate error messages
+        """
+        try:
+            response = requests.request(
+                method, url, timeout=self.timeout, **request_kwargs
+            )
+
+            # Handle response based on format requested
+            if as_http_response:
+                return HttpResponse(
+                    response.content,
+                    content_type=response.headers.get(
+                        "content-type", "application/json"
+                    ),
+                    status=response.status_code,
+                )
+
+            if response.status_code >= status.HTTP_400_BAD_REQUEST:
+                raise APIException(response.text, response.status_code)
+
+            return response.json()
+
+        except requests.Timeout as e:
+            raise APIException(
+                {"error": f"Request timed out after {self.timeout} seconds"},
+                status.HTTP_504_GATEWAY_TIMEOUT,
+            ) from e
+        except (
+            requests.ConnectionError,
+            requests.exceptions.SSLError,
+            requests.exceptions.TooManyRedirects,
+            requests.RequestException,
+        ) as e:
+            logger.error(f"Gateway connection error: {str(e)}")
+            raise APIException(
+                {"error": "Failed to connect to gateway device"},
+                status.HTTP_503_SERVICE_UNAVAILABLE,
+            ) from e
+        except json.decoder.JSONDecodeError as e:
+            raise APIException(
+                {"error": "Invalid JSON response from gateway device"},
+                status.HTTP_502_BAD_GATEWAY,
+            ) from e
+        except Exception as e:
+            logger.error(f"Unexpected error during gateway request: {str(e)}")
+            raise APIException(
+                {"error": "An unexpected error occurred during gateway request"},
+                status.HTTP_500_INTERNAL_SERVER_ERROR,
+            ) from e
+
+    def get(self, endpoint, data=None, as_http_response=False):
+        url = self._get_url(endpoint)
+        return self._make_request(
+            "GET",
+            url,
+            as_http_response=as_http_response,
+            params=data,
+            headers=self._get_headers(),
+        )
+
+    def post(self, endpoint, data=None, as_http_response=False):
+        url = self._get_url(endpoint)
+        return self._make_request(
+            "POST",
+            url,
+            as_http_response=as_http_response,
+            json=data,
+            headers=self._get_headers(),
+        )

middleware/observation/types.py

@@ -24,6 +24,63 @@ class ObservationID(str, Enum):
     WAVEFORM_RESPIRATION = "waveform_Respiration"
 
 
+class Coding(BaseModel):
+    """Represents a code from a code system"""
+
+    system: str | None = None
+    version: str | None = None
+    code: str
+    display: str | None = None
+
+
+class ObservationValueType(str, Enum):
+    boolean = "boolean"
+    decimal = "decimal"
+    integer = "integer"
+    string = "string"
+    date = "date"
+    datetime = "dateTime"
+    time = "time"
+
+
+class ObservationValue(BaseModel):
+    value: str | None = None
+    unit: Coding | None = None
+
+
+class ObservationStatus(str, Enum):
+    final = "final"
+    amended = "amended"
+    entered_in_error = "entered_in_error"
+
+
+VitalSignsCoding = Coding(
+    code="vital-signs",
+    system="http://terminology.hl7.org/CodeSystem/observation-category",
+    display="Vital Signs",
+)
+
+
+class ReferenceRange(BaseModel):
+    min: float | None = None
+    max: float | None = None
+    unit: str | None = None
+    interpretation: str
+    value: str | None = None
+
+
+class ObservationWriteSpec(BaseModel):
+    status: ObservationStatus = ObservationStatus.final
+    category: Coding = VitalSignsCoding
+    main_code: Coding
+    effective_datetime: datetime
+    value_type: ObservationValueType
+    value: ObservationValue
+    note: str | None = None
+    reference_range: list[ReferenceRange] = []
+    interpretation: str | None = None
+
+
 class Status(str, Enum):
     FINAL = "final"
     LEADS_OFF = "Message-Leads Off"
@@ -60,6 +117,7 @@ class WaveName(str, Enum):
     PLETH = "Pleth"
     RESPIRATION = "Respiration"
 
+
 class BloodPressure(BaseModel):
     value: Optional[float] = None
     unit: Optional[str] = None