Патч

src/apps/users/v1/router.py

@@ -1,15 +1,17 @@
-from datetime import datetime
+from datetime import UTC, datetime
 from json import dumps
 from logging import getLogger
 from typing import Annotated
 
 from fastapi import APIRouter, Body, Depends, status
 
+from apps.tdn.auth import token
 from apps.users.auth import login
 from apps.users.models import User
 from clients import clients as c
 from clients.tmk import schema as ts
 from clients.vitacore import schema as vs
+from shared import exceptions as e
 from shared.redis import client as cache
 
 logger = getLogger(__name__)
@@ -164,6 +166,18 @@ async def queue(_: Annotated[User, Depends(login)]):
     return await c.tmk_api.getQueue()
 
 
+@router.get('/aemd')
+async def aemd(user: Annotated[User, Depends(login)]):
+    profile = await c.vitacore_api.getProfile(user.vita_id)
+    snils = profile.SNILS.replace('-', '').replace(' ', '')
+    docs = await c.aemd_api.searchRegistryItem(patient_snils=snils)
+    doc = docs['items'][0]
+
+    return await c.aemd_api.demandContent(
+        messageId='test123', emdrId=doc['emdrId']
+    )
+
+
 # @router.post('/measurement', status_code=status.HTTP_202_ACCEPTED)
 # async def measurement(tdn_access_token: Annotated[str, Depends(token)]):
 #     patientId = '6debe050-b57e-442b-9b0e-8d304ca382b0'
@@ -182,18 +196,160 @@ async def queue(_: Annotated[User, Depends(login)]):
 
 #     return observation_measurements
 
+# created = created_at.strftime('%Y-%m-%d %H:%M:%S')
+# data = {
+#     'ad': ad,
+#     'sd': sd,
+#     'pulse': pulse,
+#     'created_at': created,
+#     'comment': comment,
+#     'status': status,
+# }
+# cache_key = f'tdn:measurement:{user.id}:{created}'
+# cache.set(cache_key, dumps(data))
+
 
 @router.post('/measurement', status_code=status.HTTP_202_ACCEPTED)
 async def measurement(
+    tdn_access_token: Annotated[str, Depends(token)],
     user: Annotated[User, Depends(login)],
     ad: Annotated[int, Body()],
     sd: Annotated[int, Body()],
     pulse: Annotated[int, Body()],
-    created_at: Annotated[datetime, Body()],
     comment: Annotated[str, Body()],
     status: Annotated[str, Body()],
 ):
-    created = created_at.strftime('%Y-%m-%d %H:%M:%S')
+    observations = await c.tdn_api.observations_search(
+        tdn_access_token, user.vita_id
+    )
+
+    if observations.total == 0:
+        raise e.NotFoundException(detail='No observations found')
+
+    ad_obsrvMeasurementUid = None
+    ad_observationUid = None
+    health_obsrvMeasurementUid = None
+    health_observationUid = None
+
+    sad_measurement = None
+    dad_measurement = None
+    pulse_measurement = None
+    health_measurement = None
+
+    observations = observations.items[::-1]
+    for observation in observations:
+        observation_measurements = (
+            await c.tdn_api.observations_measurement_search(
+                tdn_access_token, observation.uid
+            )
+        )
+
+        for measurement in observation_measurements.items:
+            if measurement.measurement.code == 'ADPULSE':
+                ad_obsrvMeasurementUid = measurement.uid
+                ad_observationUid = measurement.observationUid
+
+                for metric in measurement.obsrvMtMetrics:
+                    if metric.metric.code == 'SAD':
+                        sad_measurement = metric.uid
+
+                    if metric.metric.code == 'DAD':
+                        dad_measurement = metric.uid
+
+                    if metric.metric.code == 'PULSE':
+                        pulse_measurement = metric.uid
+
+            if measurement.measurement.code == 'HEALTH':
+                health_obsrvMeasurementUid = measurement.uid
+                health_observationUid = measurement.observationUid
+
+                for metric in measurement.obsrvMtMetrics:
+                    if metric.metric.code == 'HEALTH':
+                        health_measurement = metric.uid
+
+        if (
+            not ad_obsrvMeasurementUid
+            or not sad_measurement
+            or not dad_measurement
+            or not pulse_measurement
+            or not ad_observationUid
+            or not health_obsrvMeasurementUid
+            or not health_observationUid
+            or not health_measurement
+        ):
+            ad_obsrvMeasurementUid = None
+            sad_measurement = None
+            dad_measurement = None
+            pulse_measurement = None
+            ad_observationUid = None
+            health_obsrvMeasurementUid = None
+            health_observationUid = None
+            health_measurement = None
+
+        else:
+            break
+
+    if not ad_obsrvMeasurementUid or not ad_observationUid:
+        raise e.NotFoundException(detail='No ADPULSE measurement found')
+
+    if not sad_measurement:
+        raise e.NotFoundException(detail='No SAD measurement found')
+
+    if not dad_measurement:
+        raise e.NotFoundException(detail='No DAD measurement found')
+
+    if not pulse_measurement:
+        raise e.NotFoundException(detail='No PULSE measurement found')
+
+    if not health_obsrvMeasurementUid or not health_observationUid:
+        raise e.NotFoundException(detail='No HEALTH measurement found')
+
+    if not health_measurement:
+        raise e.NotFoundException(detail='No HEALTH measurement found')
+
+    if not health_obsrvMeasurementUid or not health_observationUid:
+        raise e.NotFoundException(detail='No HEALTH measurement found')
+
+    ad_series = await c.tdn_api.create_series(
+        tdn_access_token,
+        ad_observationUid,
+        ad_obsrvMeasurementUid,
+    )
+
+    ad_series_uid = ad_series.uid
+
+    # SAD
+    await c.tdn_api.create_series_values(
+        tdn_access_token, ad_series_uid, sad_measurement, nvalue=str(sd)
+    )
+
+    # DAD
+    await c.tdn_api.create_series_values(
+        tdn_access_token, ad_series_uid, dad_measurement, nvalue=str(ad)
+    )
+
+    # PULSE
+    await c.tdn_api.create_series_values(
+        tdn_access_token, ad_series_uid, pulse_measurement, nvalue=str(pulse)
+    )
+
+    health_series = await c.tdn_api.create_series(
+        tdn_access_token,
+        health_observationUid,
+        health_obsrvMeasurementUid,
+    )
+
+    health_series_uid = health_series.uid
+
+    # HEALTH
+    await c.tdn_api.create_series_values(
+        tdn_access_token,
+        health_series_uid,
+        health_measurement,
+        svalue=str(comment),
+    )
+
+    created = datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S')
     data = {
         'ad': ad,
         'sd': sd,
@@ -204,7 +360,6 @@ async def measurement(
     }
     cache_key = f'tdn:measurement:{user.id}:{created}'
     cache.set(cache_key, dumps(data))
-    return
 
 
 @router.get('/measurements')
@@ -213,8 +368,3 @@ async def measurements(
 ):
     data = [cache.get(key) for key in cache.keys(f'tdn:measurement:{user}:*')]
     return data
-
-
-@router.get('/aemd/test')
-async def test_route():
-    return await c.aemd_api.searchRegistryItem('16247900267')