Патч

src/clients/vitacore/api.py

@@ -1,10 +1,12 @@
+from datetime import UTC, datetime
 from logging import getLogger
 
 from fastapi import status as st
-from httpx import AsyncClient
+from httpx import AsyncClient, BasicAuth
 
 from core.config import settings
 from shared import exceptions as e
+from shared.redis import client as cache
 
 from . import schema as s
 
@@ -14,11 +16,56 @@ class VITACORE_API(AsyncClient):
         self.logger = getLogger(__name__)
         super().__init__(base_url=settings.VITACORE_BASE_URL)
 
+    async def get_token(self):
+        token = cache.get('vitacore_token')
+
+        if token is None:
+            token = await self.login()
+            cache.set('vitacore_token', token, 10800)
+
+        else:
+            token = token.decode()
+
+        return token
+
+    async def login(self):
+        req = await self.post(
+            '/auth',
+            auth=BasicAuth(
+                settings.VITACORE_USERNAME, settings.VITACORE_PASSWORD
+            ),
+        )
+
+        match req.status_code:
+            case st.HTTP_200_OK:
+                return req.text
+
+            case _:
+                self.logger.error(req.text)
+                raise e.UnknownException
+
     async def findBySnils(self, snils: str):
-        return
+        token = await self.get_token()
+        req = await self.get(
+            '/findBySnils',
+            params={'snils': snils},
+            headers={'Authorization': f'Bearer {token}'},
+        )
+
+        match req.status_code:
+            case st.HTTP_200_OK:
+                return s.PatientsModel.model_validate(req.json())
+            case _:
+                self.logger.error(req.json())
+                raise e.UnknownException
 
     async def getProfile(self, patId: str):
-        req = await self.get('/getProfile', params={'patId': patId})
+        token = await self.get_token()
+        req = await self.get(
+            '/getProfile',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
@@ -28,18 +75,24 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getDepartments(self):
-        req = await self.get('/getDepartments')
+        token = await self.get_token()
+        req = await self.get(
+            '/getDepartments', headers={'Authorization': f'Bearer {token}'}
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.OrganizationsModel.model_validate(req.json())
             case _:
-                self.logger.error(req.json())
+                self.logger.error(req.text)
                 raise e.UnknownException
 
     async def getWorkers(self, departmentId: str):
+        token = await self.get_token()
         req = await self.get(
-            '/getWorkers', params={'departmentId': departmentId}
+            '/getWorkers',
+            params={'departmentId': departmentId},
+            headers={'Authorization': f'Bearer {token}'},
         )
 
         match req.status_code:
@@ -50,7 +103,10 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getSpecsV021(self):
-        req = await self.get('/getSpecsV021')
+        token = await self.get_token()
+        req = await self.get(
+            '/getSpecsV021', headers={'Authorization': f'Bearer {token}'}
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
@@ -60,7 +116,13 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getEntries(self, patId: str):
-        req = await self.get('/getEntries', params={'patId': patId})
+        token = await self.get_token()
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        req = await self.get(
+            '/getEntries',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
@@ -76,17 +138,31 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getVaccsReport(self, patId: str):
-        req = await self.get('/getVaccsReport', params={'patId': patId})
+        token = await self.get_token()
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        req = await self.get(
+            '/getVaccsReport',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.VaccsReportModel.model_validate(req.json())
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if error.error == 'Не найдены записи по указанному patId':
+                    return s.VaccsReportModel(content='')
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getMedExamDict(self):
-        req = await self.get('/getMedExamDict')
+        token = await self.get_token()
+        req = await self.get(
+            '/getMedExamDict', headers={'Authorization': f'Bearer {token}'}
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
@@ -96,19 +172,39 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getRoutesList(self, patId: str):
-        req = await self.get('/getRoutesList', params={'patId': patId})
+        token = await self.get_token()
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        req = await self.get(
+            '/getRoutesList',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.RoutesListModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if error.error == 'Не найдены случаи по указанному patId':
+                    return s.RoutesListModel(
+                        EventID='none',
+                        EventDate=datetime.now(UTC),
+                        LpuName='fakeName',
+                        Routes=[],
+                    )
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getHospExaminations(self, patId: str, examId: str):
+        token = await self.get_token()
         req = await self.get(
             '/getHospExaminations',
             params={'patId': patId, 'examId': examId},
+            headers={'Authorization': f'Bearer {token}'},
         )
 
         match req.status_code:
@@ -119,49 +215,123 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getCurrHosp(self, patId: str):
-        req = await self.get('/getCurrHosp', params={'patId': patId})
+        token = await self.get_token()
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        req = await self.get(
+            '/getCurrHosp',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.CurHospitalizationsModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if error.error == 'Пациент не госпитализирован!':
+                    return s.CurHospitalizationsModel(
+                        Hospitalizations=[],
+                    )
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getHosps(self, patId: str):
-        req = await self.get('/getHosps', params={'patId': patId})
+        token = await self.get_token()
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        req = await self.get(
+            '/getHosps',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.HospitalizationsModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if (
+                    error.error
+                    == 'Не найдены госпитализации по указанному patId'
+                ):
+                    return s.HospitalizationsModel(
+                        Hospitalizations=[],
+                    )
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getHospRecommendations(self, patId: str):
+        token = await self.get_token()
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
         req = await self.get(
-            '/getHospRecommendations', params={'patId': patId}
+            '/getHospRecommendations',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
         )
 
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.HospRecommendationsModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if (
+                    error.error
+                    == 'Не найдены госпитализации по указанному patId'
+                ):
+                    return s.HospRecommendationsModel(
+                        EventID='none',
+                        EventDate=datetime.now(UTC),
+                        Recommendations=[],
+                    )
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getHospRoutes(self, patId: str):
-        req = await self.get('/getHospRoutes', params={'patId': patId})
+        token = await self.get_token()
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        req = await self.get(
+            '/getHospRoutes',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.HospRoutesModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if error.error == 'Пациент не госпитализирован!':
+                    return s.HospRoutesModel(
+                        EventID='none',
+                        EventDate=datetime.now(UTC),
+                        RoutesToDoctor=[],
+                        RoutesToDiagnostic=[],
+                    )
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getDiagnosticResults(self, patId: str):
-        req = await self.get('/getDiagnosticResults', params={'patId': patId})
+        token = await self.get_token()
+        req = await self.get(
+            '/getDiagnosticResults',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
@@ -171,7 +341,12 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getELNs(self, patId: str):
-        req = await self.get('/getELNs', params={'patId': patId})
+        token = await self.get_token()
+        req = await self.get(
+            '/getELNs',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK:
@@ -181,7 +356,12 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def getPatFLG(self, patId: str):
-        req = await self.get('/getPatFLG', params={'patId': patId})
+        token = await self.get_token()
+        req = await self.get(
+            '/getPatFLG',
+            params={'patId': patId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
 
         match req.status_code:
             case st.HTTP_200_OK: