Патч

src/apps/esia/v1/router.py

@@ -73,6 +73,6 @@ async def callback(session: AsyncSessionDep, code: str):
         user = existing_user
 
     access_token = secrets.token_urlsafe(32)
-    cache.set(access_token, f'user:{user.id}')
+    await cache.set(access_token, f'user:{user.id}')
 
     return s.Token(access_token=access_token)

src/apps/tdn/auth.py

@@ -3,11 +3,11 @@ from shared.redis import client as cache
 
 
 async def token():
-    access_token = cache.get('tdn_token')
+    access_token = await cache.get('tdn_token')
 
     if access_token is None:
         tokens = await c.tdn_api.signin()
-        cache.set('tdn_token', tokens.accessToken, 60)
+        await cache.set('tdn_token', tokens.accessToken, 60)
 
         return tokens.accessToken
 

src/apps/users/auth.py

@@ -16,12 +16,15 @@ async def login(
     session: AsyncSessionDep,
     credentials: Annotated[HTTPAuthorizationCredentials, Depends(BEARER)],
 ):
-    user = cache.get(credentials.credentials)
+    user = await cache.get(credentials.credentials)
 
     if user is None:
         raise e.UnauthorizedException
 
-    _, user_id = user.decode().split(':')
+    try:
+        _, user_id = user.decode().split(':')
+    except ValueError:
+        raise e.UnauthorizedException from None
 
     user_model_stmt = select(User).where(User.id == int(user_id))
     user_model = (await session.execute(user_model_stmt)).scalar_one_or_none()

src/apps/users/v1/router.py

@@ -31,7 +31,12 @@ async def get_profile(user: Annotated[User, Depends(login)]):
     return await c.vitacore_api.getProfile(user.vita_id)
 
 
-@router.get('/getDepartments', response_model=list[vs.OrganizationsModel])
+@router.get(
+    '/getDepartments',
+    responses={
+        status.HTTP_200_OK: {'model': vs.OrganizationsModel},
+    },
+)
 async def get_departments():
     """
     Get list of departments.
@@ -346,7 +351,7 @@ async def measurement(
         'status': status,
     }
     cache_key = f'tdn:measurement:{user.id}:{created}'
-    cache.set(cache_key, dumps(data))
+    await cache.set(cache_key, dumps(data))
 
 
 @router.get('/measurements')
@@ -354,6 +359,7 @@ async def measurements(
     user: Annotated[User, Depends(login)],
 ):
     data = [
-        cache.get(key) for key in cache.keys(f'tdn:measurement:{user.id}:*')
+        cache.get(key)
+        for key in await cache.keys(f'tdn:measurement:{user.id}:*')
     ]
     return data

src/clients/tdn/schema.py

@@ -102,8 +102,8 @@ class SeriesValueModel(BaseModel):
     realm: SeriesRealmModel
     createdAt: datetime
     updatedAt: datetime
-    nvalue: str | None
-    fvalue: str | None
+    nvalue: int | None
+    fvalue: float | None
     svalue: str | None
     filepath: str | None
     mobileId: str | None

src/clients/tmk/api.py

@@ -19,11 +19,11 @@ class TMK_API(AsyncClient):
         super().__init__(base_url=settings.TMK_BASE_URL, verify=False)
 
     async def get_token(self):
-        token = cache.get('tmk_token')
+        token = await cache.get('tmk_token')
 
         if token is None:
             token = await self.login()
-            cache.set('tmk_token', token, 10800)
+            await cache.set('tmk_token', token, 10800)
 
         else:
             token = token.decode()

src/clients/vitacore/api.py

@@ -3,6 +3,7 @@ from logging import getLogger
 
 from fastapi import status as st
 from httpx import AsyncClient, BasicAuth
+from orjson import dumps, loads
 
 from core.config import settings
 from shared import exceptions as e
@@ -17,16 +18,28 @@ class VITACORE_API(AsyncClient):
         super().__init__(base_url=settings.VITACORE_BASE_URL)
 
     async def get_token(self):
-        token = cache.get('vitacore_token')
+        token = await self.get_cache('vitacore_token')
 
         if token is None:
             token = await self.login()
-            cache.set('vitacore_token', token, 10800)
+            await self.set_cache(
+                'vitacore_token', dumps({'token': token}).decode(), 10800
+            )
 
-        else:
-            token = token.decode()
+            return token
 
-        return token
+        return token['token']
+
+    async def get_cache(self, key: str):
+        data = await cache.get(key)
+
+        if data:
+            return loads(data.decode())
+
+        return None
+
+    async def set_cache(self, key: str, value: str, ttl: int = 600):
+        await cache.set(key, value, ttl)
 
     async def login(self):
         req = await self.post(
@@ -45,6 +58,11 @@ class VITACORE_API(AsyncClient):
                 raise e.UnknownException
 
     async def findBySnils(self, snils: str):
+        data = await self.get_cache(f'vitacore_findBySnils:{snils}')
+
+        if data:
+            return s.PatientsModel.model_validate(data)
+
         token = await self.get_token()
         req = await self.get(
             '/findBySnils',
@@ -54,12 +72,23 @@ class VITACORE_API(AsyncClient):
 
         match req.status_code:
             case st.HTTP_200_OK:
-                return s.PatientsModel.model_validate(req.json())
+                model = s.PatientsModel.model_validate(req.json())
+                await self.set_cache(
+                    f'vitacore_findBySnils:{snils}',
+                    model.model_dump_json(),
+                    14400,
+                )
+                return model
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getProfile(self, patId: str):
+        data = await self.get_cache(f'vitacore_getProfile:{patId}')
+
+        if data:
+            return s.ProfileModel.model_validate(data)
+
         token = await self.get_token()
         req = await self.get(
             '/getProfile',
@@ -69,12 +98,23 @@ class VITACORE_API(AsyncClient):
 
         match req.status_code:
             case st.HTTP_200_OK:
-                return s.ProfileModel.model_validate(req.json())
+                model = s.ProfileModel.model_validate(req.json())
+                await self.set_cache(
+                    f'vitacore_getProfile:{patId}',
+                    model.model_dump_json(),
+                    14400,
+                )
+                return model
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getDepartments(self):
+        data = await self.get_cache('vitacore_getDepartments')
+
+        if data:
+            return s.OrganizationsModel.model_validate(data)
+
         token = await self.get_token()
         req = await self.get(
             '/getDepartments', headers={'Authorization': f'Bearer {token}'}
@@ -82,7 +122,13 @@ class VITACORE_API(AsyncClient):
 
         match req.status_code:
             case st.HTTP_200_OK:
-                return s.OrganizationsModel.model_validate(req.json())
+                model = s.OrganizationsModel.model_validate(req.json())
+                await self.set_cache(
+                    'vitacore_getDepartments',
+                    model.model_dump_json(),
+                    14400,
+                )
+                return model
             case _:
                 self.logger.error(req.text)
                 raise e.UnknownException

src/shared/redis.py

@@ -1,4 +1,4 @@
-from redis import Redis
+from redis.asyncio import Redis
 
 from core.config import settings