Фикс

Dockerfile

@@ -67,6 +67,16 @@ FROM builder-base AS production
 
 WORKDIR /app
 
+# ──────────────────────  WEASYPRINT SYSTEM DEPENDENCIES  ──────────────────────
+# These are the exact packages required for WeasyPrint to work on Debian Bookworm
+RUN apt-get update && \
+    apt-get install -y gcc libpq-dev \
+    libcairo2 libcairo2-dev libpangocairo-1.0-0 weasyprint && \
+    apt clean && \
+    rm -rf /var/cache/apt/*
+
+# ─────────────────────────────────────────────────────────────────────────────
+
 RUN chown -R appuser:appuser /app
 
 COPY --from=python-base /app/.python /app/.python

pyproject.toml

@@ -24,10 +24,15 @@ dependencies = [
     "sqlmodel==0.0.24",
     # Types
     "pydantic==2.11.7",
+    "pydantic-xml==2.18.0",
     "pydantic-settings==2.10.1",
     "pydantic-extra-types==2.10.5",
     "semver==3.0.4",
     "pyjwt==2.10.1",
+    "xmltodict==1.0.2",
+    "python-multipart==0.0.20",
+    "weasyprint==66.0",
+    "lxml==6.0.2; sys_platform != 'win32'",
     # CLI
     "typer-slim==0.16.1",
 ]

src/apps/esia/v1/router.py

@@ -49,22 +49,20 @@ async def callback(session: AsyncSessionDep, code: str):
         token.access_token, token.id_token
     )
 
-    vita_user = await c.vitacore_api.findBySnils(esia_user.snils)
+    try:
+        vita_user = await c.vitacore_api.findBySnils(esia_user.snils)
+        patId = vita_user.patId
+    except e.UnknownException:
+        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        # raise e.BadRequestException(detail='Patient not found') from None
 
-    if len(vita_user.patients) == 0:
+    existing_user_stmt = select(User).where(User.vita_id == patId).limit(1)
-        raise e.BadRequestException(detail='Patient not found')
-
-    vita_user = vita_user.patients[0]
-
-    existing_user_stmt = (
-        select(User).where(User.vita_id == vita_user.id).limit(1)
-    )
     existing_user = (
         await session.execute(existing_user_stmt)
     ).scalar_one_or_none()
 
     if existing_user is None:
-        user = User(vita_id=vita_user.id)
+        user = User(vita_id=patId)
         session.add(user)
         await session.commit()
         await session.refresh(user)
@@ -73,6 +71,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/remd/dependencies.py

@@ -0,0 +1,33 @@
+from anyio import Path
+from fastapi import HTTPException
+from lxml import etree  # type: ignore
+from weasyprint import HTML  # type: ignore
+
+
+async def get_parsable_ids():
+    parsable_files_dir = await Path('/app/apps/remd/xls').resolve()
+    parsable_ids: list[str] = [
+        file.name.split('.')[0]
+        async for file in parsable_files_dir.iterdir()
+        if await file.is_file()
+    ]
+
+    return parsable_ids
+
+
+async def convert_aemd_to_pdf(xml_str: bytes, docKind: str):
+    xml = etree.fromstring(xml_str)  # type: ignore
+    xsl = etree.parse(f'/app/apps/remd/xls/{docKind}.xsl')  # type: ignore
+    transform = etree.XSLT(xsl)  # type: ignore
+
+    html = transform(xml)  # type: ignore
+    html_str = etree.tostring(  # type: ignore
+        html, pretty_print=True, encoding='unicode', method='html'
+    )
+
+    pdf = HTML(string=html_str).write_pdf()  # type: ignore
+
+    if not pdf:
+        raise HTTPException(status_code=500, detail='PDF not generated')
+
+    return pdf

src/apps/remd/v1/router.py

@@ -0,0 +1,45 @@
+from logging import getLogger
+
+import xmltodict
+from fastapi import APIRouter, HTTPException, Request
+from orjson import dumps, loads
+
+from apps.users.v1.schema import AEMDDemandContent
+from shared.redis import client
+
+from . import schema as s
+
+logger = getLogger(__name__)
+router = APIRouter(
+    prefix='/remd',
+    tags=[
+        'REMD',
+    ],
+)
+
+
+@router.post('/callback')
+async def callback(request: Request):
+    body_bytes = await request.body()
+    if not body_bytes:
+        logger.warning('Empty body')
+        raise HTTPException(status_code=400, detail='Empty body')
+
+    body = body_bytes.decode('utf-8').replace('\r', '').replace('\n', '')
+    body_dict = xmltodict.parse(body)
+    body = s.Remd.model_validate(body_dict)
+    file_request = body.Envelope.body.sendDocumentFileRequest
+
+    data = await client.get(f'aemd_messages:{file_request.relatesToMessage}')
+
+    if not data:
+        raise HTTPException(status_code=400, detail='Message not found')
+
+    messageData = AEMDDemandContent(**loads(data))
+    await client.delete(f'aemd_messages:{file_request.relatesToMessage}')
+    await client.set(
+        f'aemd:{messageData["vitaId"]}:{messageData["emdrId"]}',
+        dumps(s.AEMDFileData(data=file_request.file.data)),
+    )
+
+    return

src/apps/remd/v1/schema.py

@@ -0,0 +1,28 @@
+from typing import TypedDict
+
+from pydantic import BaseModel, Field
+
+
+class FileModel(BaseModel):
+    data: str
+
+
+class RequestModel(BaseModel):
+    relatesToMessage: str
+    file: FileModel
+
+
+class BodyModel(BaseModel):
+    sendDocumentFileRequest: RequestModel
+
+
+class EnvelopeModel(BaseModel):
+    body: BodyModel = Field(..., alias='s:Body')
+
+
+class Remd(BaseModel):
+    Envelope: EnvelopeModel = Field(..., alias='s:Envelope')
+
+
+class AEMDFileData(TypedDict):
+    data: str

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/tmk/v1/router.py

@@ -0,0 +1,43 @@
+from json import dumps
+from logging import getLogger
+
+from fastapi import APIRouter
+from sqlmodel import select
+
+from apps.users.models import User
+from clients import clients as c
+from database import AsyncSessionDep
+from shared.exceptions import UnknownException
+from shared.redis import client as cache
+
+from . import schema as s
+
+logger = getLogger(__name__)
+router = APIRouter(
+    prefix='/tmk',
+    tags=[
+        'TMK',
+    ],
+)
+
+
+@router.post('/update')
+async def update(session: AsyncSessionDep, update: s.TMKUpdate):
+    guid = update.tmk_guid
+    info = await c.tmk_api.getInfo(guid)
+    snils = info.patient_snils
+
+    try:
+        patient = await c.vitacore_api.findBySnils(snils)
+    except UnknownException:
+        return
+
+    user_stmt = select(User).where(User.vita_id == patient.patId).limit(1)
+    user = await session.scalar(user_stmt)
+
+    if user is None:
+        return
+
+    key = f'tmk:{user.id}:{guid}'
+    value = {'id': info.id, 'status': info.tmk_status_name, 'is_read': False}
+    await cache.set(key, dumps(value))

src/apps/tmk/v1/schema.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class TMKUpdate(BaseModel):
+    tmk_guid: str

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/models.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from sqlmodel import Field, SQLModel
 
 
@@ -6,3 +8,13 @@ class User(SQLModel, table=True):
 
     id: int = Field(default=None, primary_key=True)
     vita_id: str = Field(unique=True)
+
+
+class UserDocument(SQLModel, table=True):
+    __tablename__: str = 'user_documents'  # type: ignore
+
+    id: int = Field(default=None, primary_key=True)
+    user_id: str = Field()
+    token: str
+    base64: str | None = Field(default=None)
+    created_at: datetime

src/apps/users/v1/router.py

@@ -1,16 +1,25 @@
-from datetime import datetime
+import base64
+from datetime import UTC, datetime
 from json import dumps
 from logging import getLogger
+from secrets import token_urlsafe
 from typing import Annotated
 
-from fastapi import APIRouter, Body, Depends, status
+from fastapi import APIRouter, Body, Depends, UploadFile, status
+from orjson import loads
 
+from apps.remd.dependencies import convert_aemd_to_pdf, get_parsable_ids
+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.vitacore import schema as s
+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
 
+from . import schema as s
+
 logger = getLogger(__name__)
 router = APIRouter(
     prefix='/user',
@@ -20,7 +29,12 @@ router = APIRouter(
 )
 
 
-@router.get('/getProfile', response_model=s.ProfileModel)
+@router.get(
+    '/getProfile',
+    responses={
+        status.HTTP_200_OK: {'model': vs.ProfileModel},
+    },
+)
 async def get_profile(user: Annotated[User, Depends(login)]):
     """
     Get profile of user.
@@ -30,7 +44,9 @@ async def get_profile(user: Annotated[User, Depends(login)]):
 
 @router.get(
     '/getDepartments',
-    response_model=list[s.OrganizationsModel]
+    responses={
+        status.HTTP_200_OK: {'model': vs.OrganizationsModel},
+    },
 )
 async def get_departments():
     """
@@ -39,7 +55,9 @@ async def get_departments():
     return await c.vitacore_api.getDepartments()
 
 
-@router.get('/getWorkers', response_model=s.WorkersModel)
+@router.get(
+    '/getWorkers', responses={status.HTTP_200_OK: {'model': vs.WorkersModel}}
+)
 async def get_workers(
     user: Annotated[User, Depends(login)], departmentId: str
 ):
@@ -49,7 +67,10 @@ async def get_workers(
     return await c.vitacore_api.getWorkers(departmentId)
 
 
-@router.get('/getSpecs', response_model=s.SpecsV021Model)
+@router.get(
+    '/getSpecs',
+    responses={status.HTTP_200_OK: {'model': vs.SpecsV021Model}},
+)
 async def get_specs(user: Annotated[User, Depends(login)]):
     """
     Get list of specialties.
@@ -57,7 +78,9 @@ async def get_specs(user: Annotated[User, Depends(login)]):
     return await c.vitacore_api.getSpecsV021()
 
 
-@router.get('/getEntries', response_model=s.EntriesModel)
+@router.get(
+    '/getEntries', responses={status.HTTP_200_OK: {'model': vs.EntriesModel}}
+)
 async def get_entries(user: Annotated[User, Depends(login)]):
     """
     Get list of entries for user by id.
@@ -66,10 +89,15 @@ async def get_entries(user: Annotated[User, Depends(login)]):
 
 
 @router.get('/getVaccsReport')
-async def get_vaccs_report(user: Annotated[User, Depends(login)]):
+async def get_vaccs_report(
+    user: Annotated[User, Depends(login)], resultId: str | None = None
+):
     """
     Get report of vaccinations for user by id.
     """
+    if resultId is not None:
+        return await c.vitacore_api.getDiagResultFile(resultId)
+
     return await c.vitacore_api.getVaccsReport(user.vita_id)
 
 
@@ -91,7 +119,7 @@ async def get_routes_list(user: Annotated[User, Depends(login)]):
 
 @router.get('/getHospExaminations')
 async def get_hosp_examinations(
-    user: Annotated[User, Depends(login)], examId: str
+    user: Annotated[User, Depends(login)], examId: str | None = None
 ):
     """
     Get list of hospital examinations.
@@ -158,36 +186,237 @@ async def get_pat_flg(user: Annotated[User, Depends(login)]):
     return await c.vitacore_api.getPatFLG(user.vita_id)
 
 
-# @router.post('/measurement', status_code=status.HTTP_202_ACCEPTED)
+@router.get('/queue', response_model=list[ts.QueueModel])
-# async def measurement(tdn_access_token: Annotated[str, Depends(token)]):
+async def queue(_: Annotated[User, Depends(login)]):
-#     patientId = '6debe050-b57e-442b-9b0e-8d304ca382b0'
+    """
-#     observations = await c.tdn_api.observations_search(
+    Get list of VKS queues.
-#         tdn_access_token, patientId
+    """
-#     )
+    return await c.tmk_api.getQueue()
 
-#     if observations.total == 0:
-#         raise e.NotFoundException(detail='No observations found')
 
-#     observation = observations.items[-1]
+@router.get('/aemd')
-#     observation_measurements = await
+async def get_aemd(
-#           c.tdn_api.observations_measurement_search(
+    user: Annotated[User, Depends(login)],
-#         tdn_access_token, observation.uid
+    parsable_ids: Annotated[list[str], Depends(get_parsable_ids)],
-#     )
+):
+    profile = await c.vitacore_api.getProfile(user.vita_id)
+    snils = profile.SNILS.replace('-', '').replace(' ', '')
+    docs = await c.aemd_api.searchRegistryItem(patient_snils=snils)
+    items: list[s.AEMDFile] = docs['items']
+    return_items: list[s.AEMDReturnFile] = []
 
-#     return observation_measurements
+    for item in items:
+        if item['DocKind'] not in parsable_ids:
+            continue
+
+        is_cached = await cache.get(f'aemd:{user.vita_id}:{item["emdrId"]}')
+
+        return_items.append(
+            s.AEMDReturnFile(
+                emdrId=item['emdrId'],
+                registrationDate=item['registrationDate'],
+                DocKind=item['DocKind'],
+                IsSemd=item['IsSemd'],
+                isCached=bool(is_cached),
+            )
+        )
+
+    return return_items
+
+
+@router.post('/aemd', status_code=status.HTTP_202_ACCEPTED)
+async def post_aemd(user: Annotated[User, Depends(login)], emdrId: str):
+    messageId = token_urlsafe(32)
+    data = s.AEMDDemandContent(
+        messageId=messageId, emdrId=emdrId, vitaId=user.vita_id
+    )
+    await cache.set(f'aemd_messages:{messageId}', dumps(data))
+    await c.aemd_api.demandContent(messageId=messageId, emdrId=emdrId)
+
+
+@router.get('/aemd/{emdrId}')
+async def get_aemd_file(
+    user: Annotated[User, Depends(login)], emdrId: str, docKind: str
+):
+    data = await cache.get(f'aemd:{user.vita_id}:{emdrId}')
+
+    if not data:
+        raise e.NotFoundException(status_code=404, detail='File not found')
+
+    b64 = loads(data)['data']
+    decoded = base64.b64decode(b64)
+    pdf = await convert_aemd_to_pdf(decoded, docKind)
+    b64_pdf = base64.b64encode(pdf).decode('utf-8')
+
+    return {
+        'filename': f'{emdrId}.pdf',
+        'content_type': 'application/pdf',
+        'data': b64_pdf,
+    }
 
 
 @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()],
+    status: Annotated[int, Body(ge=1, le=3)],
+    serial_number: Annotated[str, Body()],
+    ekg: UploadFile,
 ):
-    created = created_at.strftime('%Y-%m-%d %H:%M:%S')
+    vitaId = '109df850-2268-49fb-bb78-2e0f3c57314d'
+    patient = await c.tdn_api.patient_search(tdn_access_token, vitaId)
+    patientUid = patient['items'][0]['uid']
+    observations = await c.tdn_api.observations_search(
+        tdn_access_token, patientUid
+    )
+
+    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
+    health_measurement_created_at = 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' and (
+                        health_measurement_created_at is None
+                        or metric.createdAt > health_measurement_created_at
+                    ):
+                        health_measurement = metric.uid
+                        health_measurement_created_at = metric.createdAt
+
+        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
+            or not health_measurement_created_at
+        ):
+            ad_obsrvMeasurementUid = None
+            sad_measurement = None
+            dad_measurement = None
+            pulse_measurement = None
+            ad_observationUid = None
+            health_obsrvMeasurementUid = None
+            health_observationUid = None
+            health_measurement = None
+            health_measurement_created_at = 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=sd
+    )
+
+    # DAD
+    await c.tdn_api.create_series_values(
+        tdn_access_token, ad_series_uid, dad_measurement, nvalue=ad
+    )
+
+    # PULSE
+    await c.tdn_api.create_series_values(
+        tdn_access_token, ad_series_uid, pulse_measurement, nvalue=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,
+        nvalue=status,
+        svalue=comment,
+    )
+
+    # EKG
+    await c.tdn_api.ekg(
+        tdn_access_token,
+        patientUid,
+        serial_number,
+        ekg,
+    )
+
+    created = datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S')
     data = {
         'ad': ad,
         'sd': sd,
@@ -197,47 +426,52 @@ 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))
-    return
 
 
 @router.get('/measurements')
 async def measurements(
-    user: Annotated[str, Depends(login)],
+    user: Annotated[User, Depends(login)],
 ):
-    data = [cache.get(key) for key in cache.keys(f'tdn:measurement:{user}:*')]
+    data = [
+        await cache.get(key)
+        for key in await cache.keys(f'tdn:measurement:{user.id}:*')
+    ]
     return data
 
 
-@router.get('/test')
+@router.delete('/account', status_code=status.HTTP_204_NO_CONTENT)
-async def test_route():
+async def delete_account(user: Annotated[User, Depends(login)]):
-    return await c.aemd_api.searchRegistryItem('16247900267')
+    return
 
 
-@router.get('/queue')
+@router.get('/notifications')
-async def queue(user: Annotated[bool, Depends(login)]):
+async def notifications(user: Annotated[User, Depends(login)]):
-    return [
+    keys = await cache.keys(f'tmk:{user.id}:*')
-        {
+    notif: list[dict[str, str | bool]] = []
-            'id': 60,
+
-            'guid': '92b3343d-1cb2-47b2-8497-a37e38b6ba24',
+    for key in keys:
-            'tmk_date': None,
+        val = await cache.get(key)
-            'created_at': '2025-04-02 15:21:19.890343',
+
-            'code_mo': '166502',
+        if val is None:
-            'mo_name': 'ГАУЗ "ГКБ№7 ИМ. М.Н.САДЫКОВА"',
+            continue
-            'doctor_spec': '109',
+
-            'doctor_snils': None,
+        value = loads(val)
-            'patient_name': 'Иванов Петр Федорович',
+        notif_val = value.copy()
-            'patient_birthday': '1997-03-01',
+        notif.append(notif_val)
-            'patient_snils': '099-678-666 12',
+
-            'patient_policy': None,
+        if value['is_read'] is False:
-            'patient_phone': '+79123456789',
+            value['is_read'] = True
-            'patient_email': None,
+            await cache.set(key, dumps(value))
-            'tmk_status': 1,
+
-            'tmk_status_name': 'Создана',
+    return s.Notifications(
-            'tmk_cancel_reason': None,
+        notifications=notif,
-            'tmk_cancel_reason_name': None,
+    )
-            'vks_doctor_link': None,
+
-            'vks_patient_link': None,
+
-            'doctor_spec_name': 'врач-терапевт',
+@router.post('/complaint', status_code=status.HTTP_204_NO_CONTENT)
-        }
+async def complaint(
-    ]
+    user: Annotated[User, Depends(login)], complaints: s.Complaints
+):
+    cache_key = f'complaint:{user.vita_id}'
+    await cache.set(cache_key, dumps(complaints.complaints))

src/apps/users/v1/schema.py

@@ -0,0 +1,35 @@
+from typing import TypedDict
+
+from pydantic import BaseModel
+
+
+class AEMDFile(TypedDict):
+    emdrId: str
+    localUid: str
+    registrationDate: str
+    registrationDateTime: str
+    storeTillDate: str
+    DocKind: str
+    IsSemd: bool
+
+
+class AEMDReturnFile(TypedDict):
+    emdrId: str
+    registrationDate: str
+    DocKind: str
+    IsSemd: bool
+    isCached: bool
+
+
+class AEMDDemandContent(TypedDict):
+    messageId: str
+    emdrId: str
+    vitaId: str
+
+
+class Notifications(TypedDict):
+    notifications: list[dict[str, str | bool]]
+
+
+class Complaints(BaseModel):
+    complaints: str

src/apps/vitacore/v1/router.py

@@ -0,0 +1,29 @@
+from logging import getLogger
+
+from fastapi import APIRouter
+
+from shared.redis import client as cache
+
+from . import schema as s
+
+logger = getLogger(__name__)
+router = APIRouter(
+    prefix='/vitacore',
+    tags=[
+        'Витакор',
+    ],
+)
+
+
+@router.post('/hospComplaint')
+async def callback(complaint: s.HospComplaint):
+    value = await cache.get(f'complaint:{complaint.patID}')
+    value = value.decode() if value else ''
+
+    return s.ComplaintData(
+        patId=complaint.patID,
+        complaints=(
+            f'{value} | {complaint.eventId} | {complaint.datetime} | '
+            f'{complaint.MO_id}'
+        ),
+    )

src/apps/vitacore/v1/schema.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+from typing import TypedDict
+
+from pydantic import BaseModel
+
+
+class HospComplaint(BaseModel):
+    patID: str
+    eventId: str
+    datetime: datetime
+    MO_id: str
+
+
+class ComplaintData(TypedDict):
+    patId: str
+    complaints: str

src/clients/__init__.py

@@ -1,6 +1,7 @@
 from .aemd.api import AEMD_API
 from .esia.api import ESIA_API
 from .tdn.api import TDN_API
+from .tmk.api import TMK_API
 from .vitacore.api import VITACORE_API
 
 
@@ -8,6 +9,7 @@ class ClientsObject:
     _esia_api = None
     _vitacore_api = None
     _tdn_api = None
+    _tmk_api = None
     _aemd_api = None
 
     @property
@@ -31,6 +33,13 @@ class ClientsObject:
 
         return self._tdn_api
 
+    @property
+    def tmk_api(self):
+        if not self._tmk_api:
+            self._tmk_api = TMK_API()
+
+        return self._tmk_api
+
     @property
     def aemd_api(self):
         if not self._aemd_api:

src/clients/aemd/api.py

@@ -1,8 +1,12 @@
 from logging import getLogger
 
+from fastapi import status
 from httpx import AsyncClient
 
 from core.config import settings
+from shared import exceptions as e
+
+from . import schema as s
 
 
 class AEMD_API(AsyncClient):
@@ -43,4 +47,29 @@ class AEMD_API(AsyncClient):
         )
         req = await self.post('/', content=envelope)
 
-        return req.text
+        match req.status_code:
+            case status.HTTP_200_OK:
+                envelope = s.Envelope.from_xml(req.text)
+
+            case _:
+                self.logger.error(req.text)
+                raise e.UnknownException
+
+        return envelope.model_dump()['body']['response']['matches']
+
+    async def demandContent(self, messageId: str, emdrId: str):
+        envelope = self.get_envelope(
+            'demandContent',
+            f'<demandContentRequest xmlns="http://egisz.rosminzdrav.ru/iehr/emdr/service/"><messageId>{messageId}</messageId><emdrId>{emdrId}</emdrId></demandContentRequest>',
+        )
+        req = await self.post('/', content=envelope)
+
+        match req.status_code:
+            case status.HTTP_200_OK:
+                envelope = s.DemandContentEnvelope.from_xml(req.text)
+
+            case _:
+                self.logger.error(req.text)
+                raise e.UnknownException
+
+        return envelope.model_dump()['body']

src/clients/aemd/schema.py

@@ -0,0 +1,168 @@
+from pydantic import constr
+from pydantic_xml import BaseXmlModel, RootXmlModel, attr, element
+
+NSMAP = {
+    'a': 'http://www.w3.org/2005/08/addressing',
+    'b': 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd',
+    's': 'http://www.w3.org/2003/05/soap-envelope',
+    'xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+    'xsd': 'http://www.w3.org/2001/XMLSchema',
+    'd2p1': 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd',
+    'd3p1': 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd',
+}
+
+SECURITY_NSMAP = NSMAP | {
+    '': 'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd'
+}
+SIGNATURE_NSMAP = NSMAP | {'': 'http://www.w3.org/2000/09/xmldsig#'}
+RESPONSE_NSMAP = NSMAP | {'': 'http://egisz.rosminzdrav.ru/iehr/emdr/service/'}
+
+
+class Action(BaseXmlModel, tag='Action', ns='a', nsmap=NSMAP):
+    id: str = attr(name='Id', ns='d3p1')
+
+
+class MessageID(BaseXmlModel, tag='MessageID', ns='a', nsmap=NSMAP):
+    id: str = attr(name='Id', ns='d3p1')
+    description: constr(strip_whitespace=True)  # type: ignore
+
+
+class BinarySecurityToken(
+    BaseXmlModel, tag='BinarySecurityToken', nsmap=NSMAP
+):
+    id: str = attr(name='Id', ns='b')
+    ValueType: str = attr(name='ValueType')
+    EncodingType: str = attr(name='EncodingType')
+    description: constr(strip_whitespace=True)  # type: ignore
+
+
+class CanonicalizationMethod(
+    BaseXmlModel, tag='CanonicalizationMethod', nsmap=SIGNATURE_NSMAP
+):
+    algorithm: str = attr(name='Algorithm')
+
+
+class SignatureMethod(
+    BaseXmlModel, tag='SignatureMethod', nsmap=SIGNATURE_NSMAP
+):
+    algorithm: str = attr(name='Algorithm')
+
+
+class Transform(BaseXmlModel, tag='Transform', nsmap=SIGNATURE_NSMAP):
+    algorithm: str = attr(name='Algorithm')
+
+
+class Transforms(RootXmlModel, tag='Transforms', nsmap=SIGNATURE_NSMAP):  # type: ignore
+    root: list[Transform] = element()
+
+
+class DigestMethod(BaseXmlModel, tag='DigestMethod', nsmap=SIGNATURE_NSMAP):
+    algorithm: str = attr(name='Algorithm')
+
+
+class DigestValue(BaseXmlModel, tag='DigestValue', nsmap=SIGNATURE_NSMAP):
+    value: str
+
+
+class Reference(BaseXmlModel, tag='Reference', nsmap=SIGNATURE_NSMAP):
+    uri: str = attr(name='URI')
+    transforms: Transforms = element()
+    digest_method: DigestMethod = element()
+    digest_value: DigestValue = element()
+
+
+class SignedInfo(BaseXmlModel, tag='SignedInfo', nsmap=SIGNATURE_NSMAP):
+    canonicalization_method: CanonicalizationMethod = element()
+    signature_method: SignatureMethod = element()
+    references: list[Reference] = element()
+
+
+class SignatureValue(
+    BaseXmlModel, tag='SignatureValue', nsmap=SIGNATURE_NSMAP
+):
+    description: constr(strip_whitespace=True)  # type: ignore
+
+
+class SecurityTokenReference(
+    BaseXmlModel, tag='Reference', nsmap=SECURITY_NSMAP
+):
+    ValueType: str = attr(name='ValueType')
+    URI: str = attr(name='URI')
+
+
+class SecurityToken(
+    BaseXmlModel, tag='SecurityTokenReference', ns='', nsmap=SECURITY_NSMAP
+):
+    reference: SecurityTokenReference = element()
+
+
+class KeyInfo(BaseXmlModel, tag='KeyInfo', nsmap=SIGNATURE_NSMAP):
+    security_token_reference: SecurityToken = element()
+
+
+class Signature(BaseXmlModel, tag='Signature', ns='', nsmap=SIGNATURE_NSMAP):
+    signed_info: SignedInfo = element()
+    signature_value: SignatureValue = element()
+    key_info: KeyInfo = element()
+
+
+class Security(BaseXmlModel, tag='Security', ns='', nsmap=SECURITY_NSMAP):
+    binary_security_token: BinarySecurityToken = element()
+    signature: Signature = element()
+
+
+class Header(BaseXmlModel, tag='Header', ns='s', nsmap=NSMAP):
+    action: Action = element()
+    message_id: MessageID = element()
+    security: Security = element()
+
+
+class searchRegistryItemResponseItem(
+    BaseXmlModel, tag='item', nsmap=RESPONSE_NSMAP
+):
+    emdrId: str = element()
+    localUid: str = element()
+    registrationDate: str = element()
+    registrationDateTime: str = element()
+    storeTillDate: str = element()
+    DocKind: str = element()
+    IsSemd: bool = element()
+
+
+class searchRegistryItemResponseMatches(
+    BaseXmlModel, tag='matches', nsmap=RESPONSE_NSMAP
+):
+    items: list[searchRegistryItemResponseItem] = element()
+
+
+class searchRegistryItemResponse(
+    BaseXmlModel, tag='searchRegistryItemResponse', ns='', nsmap=RESPONSE_NSMAP
+):
+    status: str = element()
+    matches: searchRegistryItemResponseMatches
+
+
+class Body(BaseXmlModel, tag='Body', ns='s', nsmap=NSMAP):
+    id: str = attr(name='Id', ns='d2p1')
+    response: searchRegistryItemResponse = element()
+
+
+class Envelope(BaseXmlModel, tag='Envelope', ns='s', nsmap=NSMAP):
+    header: Header = element()
+    body: Body = element()
+
+
+class Acknowledgment(
+    BaseXmlModel, tag='acknowledgment', ns='', nsmap=RESPONSE_NSMAP
+):
+    status: str = element()
+
+
+class DemandContentBody(BaseXmlModel, tag='Body', ns='s', nsmap=NSMAP):
+    id: str = attr(name='Id', ns='d2p1')
+    acknowledgment: Acknowledgment
+
+
+class DemandContentEnvelope(BaseXmlModel, tag='Envelope', ns='s', nsmap=NSMAP):
+    header: Header = element()
+    body: DemandContentBody = element()

src/clients/tdn/api.py

@@ -1,7 +1,9 @@
+from datetime import UTC, datetime
 from json import dumps
 from logging import getLogger
 from urllib.parse import quote, urlencode
 
+from fastapi import UploadFile
 from fastapi import status as st
 from httpx import AsyncClient
 
@@ -16,6 +18,7 @@ class TDN_API(AsyncClient):
         self.logger = getLogger(__name__)
         super().__init__(
             base_url=settings.TDN_BASE_URL,
+            verify=False,
             headers={
                 'Content-Type': 'application/json',
             },
@@ -37,20 +40,28 @@ class TDN_API(AsyncClient):
                 raise e.UnknownException
 
     async def patient_search(self, access_token: str, vitaId: str):
-        data = quote(dumps({'vitaId': vitaId}))
+        query = (
+            quote(dumps({'where': {'vitaId': vitaId}}))
+            .replace('%7B', '{')
+            .replace('%7D', '}')
+        )
 
-        _ = await self.get(
+        req = await self.get(
-            '/ddn/patient/search',
+            f'/ddn/patients/search?query={query}',
-            params={'query': data},
             headers={'Authorization': f'Bearer {access_token}'},
         )
 
+        return req.json()
+
     async def observations_search(self, access_token: str, patientUid: str):
-        data = quote(dumps({'where': {'patientUid': patientUid}}))
+        query = (
+            quote(dumps({'where': {'patientUid': patientUid}}))
+            .replace('%7B', '{')
+            .replace('%7D', '}')
+        )
 
         res = await self.get(
-            '/ddn/observations/search',
+            f'/ddn/observations/search?query={query}',
-            params={'query': data},
             headers={'Authorization': f'Bearer {access_token}'},
         )
 
@@ -64,18 +75,6 @@ class TDN_API(AsyncClient):
     async def observations_measurement_search(
         self, access_token: str, observationUid: str
     ):
-        # data = urlencode(
-        #     dumps(
-        #         {
-        #             'where': {'observationUid': observationUid},
-        #             'relations': [
-        #                 'measurement',
-        #                 'obsrvMtMetrics',
-        #                 'obsrvMtMetrics.metric',
-        #             ],
-        #         }
-        #     )
-        # )
         encoded_query = urlencode(
             {
                 'query': dumps(
@@ -104,3 +103,102 @@ class TDN_API(AsyncClient):
             case _:
                 self.logger.error(res.json())
                 raise e.UnknownException
+
+    async def create_series(
+        self, access_token: str, observationUid: str, obsrvMeasurementUid: str
+    ):
+        now = datetime.now(UTC)
+        tz_offset = now.strftime('%z')
+        formatted_offset = (
+            f'{tz_offset[:3]}:{tz_offset[3:]}' if tz_offset else '+0000'
+        )
+        date_str = (
+            f'{now.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]} {formatted_offset}'
+        )
+
+        res = await self.patch(
+            '/ddn/observation/series',
+            headers={'Authorization': f'Bearer {access_token}'},
+            json={
+                'observationUid': observationUid,
+                'obsrvMeasurementUid': obsrvMeasurementUid,
+                'date': date_str,
+            },
+        )
+
+        match res.status_code:
+            case st.HTTP_200_OK:
+                return s.SeriesModel.model_validate(res.json())
+            case _:
+                self.logger.error(res.json())
+                raise e.UnknownException
+
+    async def create_series_values(
+        self,
+        access_token: str,
+        seriesUid: str,
+        obsrvMtMetricUid: str,
+        *,
+        nvalue: int | None = None,
+        fvalue: float | None = None,
+        svalue: str | None = None,
+    ):
+        data: dict[str, str | int | float] = {
+            'seriesUid': seriesUid,
+            'obsrvMtMetricUid': obsrvMtMetricUid,
+        }
+
+        if nvalue is not None:
+            data['nvalue'] = nvalue
+
+        if fvalue is not None:
+            data['fvalue'] = fvalue
+
+        if svalue is not None:
+            data['svalue'] = svalue
+
+        res = await self.patch(
+            '/ddn/observation/series-values',
+            headers={'Authorization': f'Bearer {access_token}'},
+            json=data,
+        )
+
+        match res.status_code:
+            case st.HTTP_200_OK:
+                return s.SeriesValueModel.model_validate(res.json())
+            case _:
+                self.logger.error(res.json())
+                raise e.UnknownException
+
+    async def ekg(
+        self,
+        access_token: str,
+        patientUid: str,
+        serial_number: str,
+        ecg_file: UploadFile,
+    ):
+        req = await self.post(
+            '/ddn/observation/series-values/ecg/krb02',
+            headers={
+                'Authorization': f'Bearer {access_token}',
+                'Content-Type': 'multipart/form-data; boundary=+++',
+            },
+            data={
+                'patientUid': patientUid,
+                'serialNumber': serial_number,
+            },
+            files={
+                'ecg': (
+                    ecg_file.filename,
+                    ecg_file.file,
+                    ecg_file.content_type or 'application/octet-stream',
+                )
+            },
+        )
+
+        match req.status_code:
+            case st.HTTP_201_CREATED:
+                return s.EkgModel.model_validate(req.json())
+            case _:
+                self.logger.error(req.json())
+                raise e.UnknownException

src/clients/tdn/schema.py

@@ -68,7 +68,7 @@ class ObservationMeasurementModel(BaseModel):
     timeFrequency: int
     timePeriod: int
     timePeriodMeasureUid: str
-    timeOfDay: list[str]
+    timeOfDay: list[str] | None
     comment: str | None
     mobileId: str | None
     measurement: MeasurementModel
@@ -78,3 +78,38 @@ class ObservationMeasurementModel(BaseModel):
 class ObservationMeasurementsModel(BaseModel):
     items: list[ObservationMeasurementModel]
     total: int
+
+
+class SeriesRealmModel(BaseModel):
+    uid: str
+
+
+class SeriesModel(BaseModel):
+    observationUid: str
+    obsrvMeasurementUid: str
+    date: str
+    realm: SeriesRealmModel
+    mobileId: str | None
+    uid: str
+    createdAt: datetime
+    updatedAt: datetime
+
+
+class SeriesValueModel(BaseModel):
+    uid: str
+    seriesUid: str
+    obsrvMtMetricUid: str
+    realm: SeriesRealmModel
+    createdAt: datetime
+    updatedAt: datetime
+    nvalue: int | None
+    fvalue: float | None
+    svalue: str | None
+    filepath: str | None
+    mobileId: str | None
+    tisId: str | None
+
+
+class EkgModel(BaseModel):
+    success: bool
+    # result: ...

src/clients/tmk/api.py

@@ -0,0 +1,111 @@
+from datetime import date
+from logging import getLogger
+from typing import Literal
+
+from fastapi import status as st
+from httpx import AsyncClient
+
+from core.config import settings
+from shared import exceptions as e
+from shared.functions import clean_params
+from shared.redis import client as cache
+
+from . import schema as s
+
+
+class TMK_API(AsyncClient):
+    def __init__(self):
+        self.logger = getLogger(__name__)
+        super().__init__(base_url=settings.TMK_BASE_URL, verify=False)
+
+    async def get_token(self):
+        token = await cache.get('tmk_token')
+
+        if token is None:
+            token = await self.login()
+            await cache.set('tmk_token', token, 10800)
+
+        else:
+            token = token.decode()
+
+        return token
+
+    async def login(self):
+        req = await self.post(
+            '/auth',
+            json={
+                'login': settings.TMK_LOGIN,
+                'password': settings.TMK_PASSWORD,
+            },
+        )
+
+        match req.status_code:
+            case st.HTTP_200_OK:
+                return s.AccessTokenModel.model_validate(
+                    req.json()
+                ).access_token
+
+            case _:
+                self.logger.error(req.json())
+                raise e.UnknownException
+
+    async def getQueue(
+        self,
+        code_mo: str | None = None,
+        doctor_spec: str | None = None,
+        doctor_snils: str | None = None,
+        doctor_snils_strict: Literal['y', 'n'] = 'n',
+        date_begin: date | None = None,
+        date_end: date | None = None,
+        patient_snils: str | None = None,
+        patient_fio: str | None = None,
+        patient_policy: str | None = None,
+        patient_phone: str | None = None,
+        patient_birthdate: date | None = None,
+        tk_status: str | None = None,
+    ):
+        token = await self.get_token()
+        req = await self.get(
+            '/getQueue',
+            headers={'Authorization': f'Bearer {token}'},
+            params=clean_params(
+                {
+                    'code_mo': code_mo,
+                    'doctor_spec': doctor_spec,
+                    'doctor_snils': doctor_snils,
+                    'doctor_snils_strict': doctor_snils_strict,
+                    'date_begin': date_begin,
+                    'date_end': date_end,
+                    'patient_snils': patient_snils,
+                    'patient_fio': patient_fio,
+                    'patient_policy': patient_policy,
+                    'patient_phone': patient_phone,
+                    'patient_birthdate': patient_birthdate,
+                    'tk_status': tk_status,
+                }
+            ),
+        )
+
+        match req.status_code:
+            case st.HTTP_200_OK:
+                return [s.QueueModel.model_validate(i) for i in req.json()]
+
+            case _:
+                self.logger.error(req.json())
+                raise e.UnknownException
+
+    async def getInfo(self, guid: str):
+        token = await self.get_token()
+        req = await self.get(
+            '/getTMKInfo',
+            headers={'Authorization': f'Bearer {token}'},
+            params={'guid': guid},
+        )
+
+        match req.status_code:
+            case st.HTTP_200_OK:
+                return s.QueueModel.model_validate(req.json())
+
+            case _:
+                self.logger.error(req.json())
+                raise e.UnknownException

src/clients/tmk/schema.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class AccessTokenModel(BaseModel):
+    access_token: str
+
+
+class QueueModel(BaseModel):
+    id: int
+    guid: str
+    created_at: datetime
+    code_mo: int | None
+    mo_name: str | None
+    doctor_spec: str
+    doctor_snils: str | None
+    doctor_fio: str | None
+    patient_name: str | None
+    patient_birthday: datetime | None
+    patient_snils: str
+    patient_policy: str | None
+    patient_phone: str | None
+    patient_email: str | None
+    tmk_status: int
+    tmk_status_name: str
+    tmk_cancel_reason: int | None
+    tmk_cancel_reason_name: str | None
+    vks_doctor_link: str | None
+    vks_patient_link: str | None
+    doctor_spec_name: str | None

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:
+            return token
-            token = token.decode()
 
-        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_findBySnils2:{snils}')
+
+        if data:
+            return s.PatientModel.model_validate(data)
+
         token = await self.get_token()
         req = await self.get(
             '/findBySnils',
@@ -54,12 +72,24 @@ class VITACORE_API(AsyncClient):
 
         match req.status_code:
             case st.HTTP_200_OK:
-                return s.PatientsModel.model_validate(req.json())
+                model = s.PatientModel.model_validate(req.json())
+                await self.set_cache(
+                    f'vitacore_findBySnils2:{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 +99,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,12 +123,23 @@ 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
 
     async def getWorkers(self, departmentId: str):
+        data = await self.get_cache(f'vitacore_getWorkers:{departmentId}')
+
+        if data:
+            return s.WorkersModel.model_validate(data)
+
         token = await self.get_token()
         req = await self.get(
             '/getWorkers',
@@ -97,12 +149,27 @@ class VITACORE_API(AsyncClient):
 
         match req.status_code:
             case st.HTTP_200_OK:
-                return s.WorkersModel.model_validate(req.json()['workers'])
+                data = s.WorkersModel.model_validate(req.json())
+                await self.set_cache(
+                    f'vitacore_getWorkers:{departmentId}',
+                    data.model_dump_json(),
+                    14400,
+                )
+                return data
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                return s.WorkersModel(Workers=[])
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getSpecsV021(self):
+        data = await self.get_cache('vitacore_getSpecsV021')
+
+        if data:
+            return s.SpecsV021Model.model_validate(data)
+
         token = await self.get_token()
         req = await self.get(
             '/getSpecsV021', headers={'Authorization': f'Bearer {token}'}
@@ -110,14 +177,22 @@ class VITACORE_API(AsyncClient):
 
         match req.status_code:
             case st.HTTP_200_OK:
-                return s.SpecsV021Model.model_validate(req.json())
+                data = s.SpecsV021Model.model_validate(req.json())
+                await self.set_cache(
+                    'vitacore_getSpecsV021',
+                    data.model_dump_json(),
+                    14400,
+                )
+                return data
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getEntries(self, patId: str):
         token = await self.get_token()
-        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         req = await self.get(
             '/getEntries',
             params={'patId': patId},
@@ -139,7 +214,9 @@ class VITACORE_API(AsyncClient):
 
     async def getVaccsReport(self, patId: str):
         token = await self.get_token()
-        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         req = await self.get(
             '/getVaccsReport',
             params={'patId': patId},
@@ -152,13 +229,22 @@ class VITACORE_API(AsyncClient):
             case st.HTTP_206_PARTIAL_CONTENT:
                 error = s.ErrorModel.model_validate(req.json())
 
-                if error.error == 'Не найдены записи по указанному patId':
+                if (
+                    error.error == 'Не найдены записи по указанному patId'
+                    or error.error
+                    == 'Не найдены вакцинации по данному пациенту'
+                ):
                     return s.VaccsReportModel(content='')
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getMedExamDict(self):
+        data = await self.get_cache('vitacore_getMedExamDict')
+
+        if data:
+            return s.MedExamDictModel.model_validate(data)
+
         token = await self.get_token()
         req = await self.get(
             '/getMedExamDict', headers={'Authorization': f'Bearer {token}'}
@@ -166,14 +252,22 @@ class VITACORE_API(AsyncClient):
 
         match req.status_code:
             case st.HTTP_200_OK:
-                return s.MedExamDictModel.model_validate(req.json())
+                data = s.MedExamDictModel.model_validate(req.json())
+                await self.set_cache(
+                    'vitacore_getMedExamDict',
+                    data.model_dump_json(),
+                    14400,
+                )
+                return data
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getRoutesList(self, patId: str):
         token = await self.get_token()
-        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         req = await self.get(
             '/getRoutesList',
             params={'patId': patId},
@@ -191,7 +285,7 @@ class VITACORE_API(AsyncClient):
                     return s.RoutesListModel(
                         EventID='none',
                         EventDate=datetime.now(UTC),
-                        LpuName='fakeName',
+                        LpuName='',
                         Routes=[],
                     )
 
@@ -199,7 +293,10 @@ class VITACORE_API(AsyncClient):
                 self.logger.error(req.json())
                 raise e.UnknownException
 
-    async def getHospExaminations(self, patId: str, examId: str):
+    async def getHospExaminations(self, patId: str, examId: str | None = None):
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         token = await self.get_token()
         req = await self.get(
             '/getHospExaminations',
@@ -210,13 +307,27 @@ class VITACORE_API(AsyncClient):
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.HospExaminationsModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if error.error == 'Пациент не госпитализирован!':
+                    return s.HospExaminationsModel(
+                        EventID='none',
+                        EventDate=datetime.now(UTC),
+                        LpuName='',
+                        Examinations=[],
+                    )
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
 
     async def getCurrHosp(self, patId: str):
         token = await self.get_token()
-        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         req = await self.get(
             '/getCurrHosp',
             params={'patId': patId},
@@ -228,12 +339,9 @@ class VITACORE_API(AsyncClient):
                 return s.CurHospitalizationsModel.model_validate(req.json())
 
             case st.HTTP_206_PARTIAL_CONTENT:
-                error = s.ErrorModel.model_validate(req.json())
+                return s.CurHospitalizationsModel(
-
+                    Hospitalizations=[],
-                if error.error == 'Пациент не госпитализирован!':
+                )
-                    return s.CurHospitalizationsModel(
-                        Hospitalizations=[],
-                    )
 
             case _:
                 self.logger.error(req.json())
@@ -241,7 +349,9 @@ class VITACORE_API(AsyncClient):
 
     async def getHosps(self, patId: str):
         token = await self.get_token()
-        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         req = await self.get(
             '/getHosps',
             params={'patId': patId},
@@ -269,7 +379,9 @@ class VITACORE_API(AsyncClient):
 
     async def getHospRecommendations(self, patId: str):
         token = await self.get_token()
-        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         req = await self.get(
             '/getHospRecommendations',
             params={'patId': patId},
@@ -299,7 +411,9 @@ class VITACORE_API(AsyncClient):
 
     async def getHospRoutes(self, patId: str):
         token = await self.get_token()
-        patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+        if patId == '9a4d4b06-5928-4101-b95e-e5ba03a1abfd':
+            patId = 'b66a85f1-4aaa-4db8-942a-2de44341824e'
+
         req = await self.get(
             '/getHospRoutes',
             params={'patId': patId},
@@ -351,6 +465,13 @@ class VITACORE_API(AsyncClient):
         match req.status_code:
             case st.HTTP_200_OK:
                 return s.ELNsModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if error.error == 'Пациент не госпитализирован!':
+                    return s.ELNsModel(PatientELNs=[])
+
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
@@ -369,3 +490,28 @@ class VITACORE_API(AsyncClient):
             case _:
                 self.logger.error(req.json())
                 raise e.UnknownException
+
+    async def getDiagResultFile(self, resultId: str):
+        token = await self.get_token()
+        req = await self.get(
+            '/getDiagResultFile',
+            params={'resultId': resultId},
+            headers={'Authorization': f'Bearer {token}'},
+        )
+
+        match req.status_code:
+            case st.HTTP_200_OK:
+                return s.DiagResultFileModel.model_validate(req.json())
+
+            case st.HTTP_206_PARTIAL_CONTENT:
+                error = s.ErrorModel.model_validate(req.json())
+
+                if (
+                    error.error == 'Не найдены проведенные исследования по '
+                    'данному идентификатору'
+                ):
+                    return s.DiagResultFileModel(content='')
+
+            case _:
+                self.logger.error(req.json())
+                raise e.UnknownException

src/clients/vitacore/schema.py

@@ -1,14 +1,19 @@
 from datetime import datetime
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 
 class ErrorModel(BaseModel):
-    error: str = Field(title='Текст ошибки')
+    model_config = ConfigDict(
+        validate_by_alias=True,
+        validate_by_name=True,
+    )
+
+    error: str = Field(title='Текст ошибки', alias='message')
 
 
 class PatientModel(BaseModel):
-    id: str = Field(
+    patId: str = Field(
         title='Идентификатор пациента',
         examples=['b62e9f22-a871-4c52-96d6-559c707a716d'],
     )
@@ -18,18 +23,6 @@ class PatientModel(BaseModel):
     middleName: str = Field(title='Отчество', examples=['Пациентович'])
     birthDate: datetime = Field(title='Дата рождения', examples=['2024-10-16'])
     gender: str = Field(title='Пол', examples=['М'])
-    docType: str = Field(title='Тип документа', examples=['Паспорт РФ'])
-    docSer: str = Field(title='Серия документа', examples=['12 34'])
-    docNum: str = Field(title='Номер документа', examples=['999999'])
-    polNum: str = Field(title='Номер полиса', examples=['999999'])
-    address1: str = Field(
-        title='Адрес проживания',
-        examples=['г. Москва, ул. Пушкина, д. 1'],
-    )
-
-
-class PatientsModel(BaseModel):
-    patients: list[PatientModel]
 
 
 class TrustedPersonModel(BaseModel):
@@ -72,27 +65,39 @@ class ProfileModel(BaseModel):
     )
     docSer: str = Field(title='Серия документа', examples=['III-КБ'])
     docNum: str = Field(title='Номер документа', examples=['999999'])
-    # ENP: str = Field(
+    ENP: str | None = Field(
-    #     title='Единый номер полиса ОМС (16-ти значный)',  # noqa: RUF003
+        title='Единый номер полиса ОМС (16-ти значный)',
-    #     examples=['?'],
+        examples=['?'],
-    # )
+        default=None,
+    )
+    phones: str | None = Field(
+        title='Номера телефонов',
+        examples=['+7 (999) 112-33-21 (моб.)'],
+        default=None,
+    )
     addressReal: str = Field(
         title='Адрес проживания',
         examples=[
             '420000, Татарстан Респ, г.Казань, ул.Магистральная (Большие Клыки), д.1, кв.1'  # noqa: E501
         ],
     )
-    # attachBranchId: str = Field(
+    attachBranchId: str = Field(
-    #     title='Идентификатор СТП прикреплния',
+        title='Идентификатор СТП прикреплния',
-    #     examples=['string'],
+        examples=['string'],
-    # )
+    )
-    # attachState: str = Field(
+    attachState: str = Field(
-    #     title='Номер участка',
+        title='Номер участка',
-    #     examples=['99'],
+        examples=['99'],
-    # )
+    )
     trustedPersons: list[TrustedPersonModel] = Field(
         title='Информация о представителе', default=[]
     )
+    dispFlag: bool | None = Field(
+        title='Флаг диспансеризации', examples=['false'], default=None
+    )
+    dispDate: datetime | None = Field(
+        title='Дата диспансеризации', default=None
+    )
 
 
 class DepartmentAddressModel(BaseModel):
@@ -140,6 +145,10 @@ class DepartmentModel(BaseModel):
         ', для филиалов: Стационар / Поликлиника / ФАП / Амбулатория)',
         examples=['Юридическое лицо'],
     )
+    phone: str | None = Field(
+        title='Номер телефона',
+        default=None,
+    )
     inn: str | None = Field(title='ИНН', examples=['0000000000'], default=None)
     ogrn: str | None = Field(
         title='ОГРН', examples=['1149204047816'], default=None
@@ -180,21 +189,30 @@ class WorkersPositionModel(BaseModel):
         title='ФРМР. Должности медицинского персонала',
         examples=['врач-онколог'],
     )
-    positionSpecialityCode: str = Field(
+    positionSpecialityCode: str | None = Field(
         title='Код специальности по V021',
         examples=['41'],
+        default=None,
     )
-    positionSpecialityName: str = Field(
+    positionSpecialityName: str | None = Field(
         title='Наименование специальности по V021',
         examples=['Онкология'],
+        default=None,
     )
     rate: float = Field(
         title='Ставка',
         examples=[0.5],
     )
 
+    @field_validator('rate', mode='before')
+    def convert_comma(cls, v: str | float):
+        if isinstance(v, str):
+            return v.replace(',', '.')
 
-class WorkersModel(BaseModel):
+        return v
+
+
+class WorkerModel(BaseModel):
     id: str = Field(
         title='Идентификатор сотрудника',
         examples=['dc911302-5044-46f4-b935-c6ffd85eb68f'],
@@ -205,9 +223,17 @@ class WorkersModel(BaseModel):
     )
     firstName: str = Field(title='Имя', examples=['Владимир'])
     lastName: str = Field(title='Фамилия', examples=['Камашев'])
-    middleName: str = Field(title='Отчество', examples=['Михайлович'])
+    middleName: str | None = Field(
-    birthDate: datetime = Field(title='Дата рождения', examples=['30.05.1961'])
+        title='Отчество', examples=['Михайлович'], default=None
-    positions: list[WorkersPositionModel]
+    )
+    birthDate: datetime | None = Field(
+        title='Дата рождения', examples=['30.05.1961'], default=None
+    )
+    positions: list[WorkersPositionModel] = []
+
+
+class WorkersModel(BaseModel):
+    Workers: list[WorkerModel]
 
 
 class SpecialityV021Model(BaseModel):
@@ -398,11 +424,12 @@ class ExaminationModel(BaseModel):
             'style="BORDER-TOP: #ffffff 1px..... </TABLE>'
         ],
     )
-    Recommendation: str = Field(
+    Recommendation: str | None = Field(
         title='Идентификатор результата исследования',
         examples=['рекомендации 1 тест'],
+        default=None,
     )
-    SEMDs: list[SEMDModel] = Field(title='Список СЭМД')
+    SEMDs: list[SEMDModel] | None = Field(title='Список СЭМД', default=None)
 
 
 class HospExaminationsModel(BaseModel):
@@ -414,7 +441,9 @@ class HospExaminationsModel(BaseModel):
         title='Дата обращения', examples=['2025-08-01']
     )
     LpuName: str = Field(title='Наименование МО', examples=['ГАУЗ "ГКБ №7"'])
-    Examinations: list[ExaminationModel] = Field(title='Список осмотров')
+    Examinations: list[ExaminationModel] | None = Field(
+        title='Список осмотров', default=None
+    )
 
 
 class RouteToDoctorModel(BaseModel):
@@ -484,13 +513,15 @@ class BaseHospitalizationModel(BaseModel):
         ],
         default=None,
     )
-    HospitalizationType: str = Field(
+    HospitalizationType: str | None = Field(
-        title='Тип госпитализации', examples=['экстренная']
+        title='Тип госпитализации', examples=['экстренная'], default=None
     )
-    HospitalizationReason: str = Field(
+    HospitalizationReason: str | None = Field(
-        title='Причина госпитализации', examples=['заболевание']
+        title='Причина госпитализации', examples=['заболевание'], default=None
+    )
+    Division: str | None = Field(
+        title='Отделение', examples=['Кардиология №1'], default=None
     )
-    Division: str = Field(title='Отделение', examples=['Кардиология №1'])
     LpuName: str = Field(title='Наименование МО', examples=['ГАУЗ "ГКБ №7"'])
 
 
@@ -527,6 +558,7 @@ class RecommendationModel(BaseModel):
     Recommendation: str = Field(
         title='Текст рекомендации', examples=['рекомендации тест']
     )
+    Post: str = Field(title='Врач', examples=['Тестовый В.С.'])
 
 
 class HospRecommendationsModel(BaseModel):
@@ -608,10 +640,10 @@ class ProlongationModel(BaseModel):
 
 
 class PatientELNModel(BaseModel):
-    PatientSNILS: str = Field(
+    PatientSNILS: str | None = Field(
         title='СНИЛС болеющего', examples=['000-000-600 01']
     )
-    Number: str = Field(
+    Number: str | None = Field(
         title='Номер листа нетрудоспособности', examples=['910040906829']
     )
     OpenDate: datetime | None = Field(
@@ -633,11 +665,13 @@ class PatientELNModel(BaseModel):
             'обострение)'
         ],
     )
-    Prolongations: list[ProlongationModel] = Field(title='Продления')
+    Prolongations: list[ProlongationModel] | None = Field(
-    LpuName: str = Field(
+        title='Продления', default=None
+    )
+    LpuName: str | None = Field(
         title='Наименование МО', examples=['ГАУЗ Новошешминская ЦРБ']
     )
-    BranchAddress: str = Field(
+    BranchAddress: str | None = Field(
         title='Адрес подразделения выдачи',
         examples=['Республика Татарстан,с.Новошешминск, ул.Майская, д.8'],
     )
@@ -672,3 +706,12 @@ class PatientFLGModel(BaseModel):
         title='Контингент (флюорография)',
         examples=['Неорганизованное население'],
     )
+    PrgDecision: str | None = Field(
+        title='Решение (флюорография)',
+        examples=['Требует дообследования'],
+        default=None,
+    )
+
+
+class DiagResultFileModel(BaseModel):
+    content: str

src/core/config.py

@@ -41,9 +41,6 @@ class Settings(BaseSettings):
     # Loki Logging
     LOKI_URL: str | None = Field(default=None)
 
-    # Environment
-    TMK_BASE_URL: str = Field(default='https://tmk-api.tatar.ru/api')
-
     # ESIA
     ESIA_BASE_URL: str = Field(default='https://esia.gosuslugi.ru')
     ESIA_CLIENT_ID: str = Field(default='')
@@ -70,6 +67,11 @@ class Settings(BaseSettings):
     TDN_LOGIN: str = Field(default='')
     TDN_PASSWORD: str = Field(default='')
 
+    # TMK
+    TMK_BASE_URL: str = Field(default='https://tmk-api.tatar.ru/api')
+    TMK_LOGIN: str = Field(default='admin')
+    TMK_PASSWORD: str = Field(default='12345')
+
     @model_validator(mode='after')
     def celery_env(self):
         environ['CELERY_BROKER_URL'] = self.REDIS_URL

src/core/log.py

@@ -26,9 +26,21 @@ class Config:
     def __init__(self):
         self.version = 1
         self.disable_existing_loggers = False
+        self.formatters = self._get_formatters()
         self.handlers = self._get_handlers()
         self.loggers = self._get_loggers()
 
+    @staticmethod
+    def _get_formatters() -> dict[str, Any]:
+        # Common formatter that includes logger name
+        fmt = '%(asctime)s | %(levelname)-8s | %(message)s'
+        return {
+            'default': {
+                'format': fmt,
+                'datefmt': '%Y-%m-%d %H:%M:%S',
+            }
+        }
+
     @staticmethod
     def _get_handlers():
         handlers: dict[str, Any] = {
@@ -36,6 +48,7 @@ class Config:
                 'class': 'logging.StreamHandler',
                 'level': logging.INFO,
                 'stream': 'ext://sys.stderr',
+                'formatter': 'default',
             }
         }
 
@@ -53,12 +66,16 @@ class Config:
             },
         }
 
+        loggers['fontTools'] = {'level': logging.CRITICAL, 'propagate': False}
+        loggers['weasyprint'] = {'level': logging.CRITICAL, 'propagate': False}
+
         return loggers
 
     def render(self):
         return {
             'version': self.version,
             'disable_existing_loggers': self.disable_existing_loggers,
+            'formatters': self.formatters,
             'handlers': self.handlers,
             'loggers': self.loggers,
         }

src/core/routers/v1.py

@@ -1,7 +1,10 @@
 from fastapi import APIRouter, HTTPException
 
 from apps.esia.v1.router import router as esia_router
+from apps.remd.v1.router import router as remd_router
+from apps.tmk.v1.router import router as tmk_router
 from apps.users.v1.router import router as users_router
+from apps.vitacore.v1.router import router as vitacore_router
 
 from . import get_openapi_schema, get_swagger_html
 
@@ -9,6 +12,9 @@ router = APIRouter(prefix='/v1')
 
 router.include_router(esia_router)
 router.include_router(users_router)
+router.include_router(remd_router)
+router.include_router(vitacore_router)
+router.include_router(tmk_router)
 
 openapi_schema = get_openapi_schema(router)
 swagger_ui_html = get_swagger_html(router)

src/shared/functions.py

@@ -0,0 +1,5 @@
+from typing import Any
+
+
+def clean_params(data: dict[Any, Any]):
+    return {k: v for k, v in data.items() if v is not None}

src/shared/redis.py

@@ -1,5 +1,45 @@
-from redis import Redis
+from collections.abc import Callable, Coroutine
+from functools import wraps
+from typing import Any, TypeVar
 
+from fastapi.responses import ORJSONResponse
+from orjson import dumps, loads
+from redis.asyncio import Redis
+
+from apps.users.models import User
 from core.config import settings
 
 client = Redis.from_url(settings.REDIS_URL)
+T = TypeVar('T')
+
+
+def cache_response(ttl: int = 60, namespace: str = 'main'):
+    def decorator(
+        func: Callable[..., Coroutine[Any, Any, T]],
+    ) -> Callable[..., Coroutine[Any, Any, T | ORJSONResponse]]:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any):
+            cache_key = f'endpoints:{namespace}_{func.__name__}'
+            user = kwargs.get('user')
+            user_id = kwargs.get('user_id')
+
+            if user_id:
+                cache_key += f':{user_id}'
+
+            if isinstance(user, User):
+                cache_key += f':{user.id}'
+
+            cached_value = await client.get(cache_key)
+            if cached_value:
+                return ORJSONResponse(
+                    content=loads(cached_value), headers={'X-Cache': 'hit'}
+                )
+
+            response = await func(*args, **kwargs)
+            await client.set(cache_key, dumps(response), ex=ttl)
+
+            return response
+
+        return wrapper
+
+    return decorator