export-direction-fix: убрал обязательный для первой формы direction при экспорте формы

Reviewed-on: #30

api/alembic.ini

@@ -0,0 +1,141 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# database URL.  This is consumed by the user-maintained env.py script only.
+# other means of configuring database URLs may be customized within the env.py
+# file.
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration.  This is also consumed by the user-maintained
+# env.py script only.
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

api/alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

api/alembic/env.py

@@ -0,0 +1,78 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = None
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

api/alembic/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

api/requirements.txt

@@ -15,3 +15,4 @@ asyncpg==0.30.0
 pytest==8.3.2
 pytest-asyncio==0.24.0
 raisa-fastapi-protected-api==1.0.0
+openpyxl

api/src/api/v1/admin.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import text
+from sqlalchemy.exc import SQLAlchemyError
+
+from src.api.v1.deps import require_admin
+from src.db.base import engine
+from src.db.models.app_user import AppUser
+
+router = APIRouter(prefix="/admin", tags=["admin"])
+
+
+@router.post("/refresh-tree")
+async def refresh_tree(current_user: AppUser = Depends(require_admin)):
+    """Обновляет MV дерева статей расходов."""
+    try:
+        async with engine.connect() as conn:
+            # CONCURRENTLY требует autocommit-режим.
+            conn = await conn.execution_options(isolation_level="AUTOCOMMIT")
+            await conn.execute(text("REFRESH MATERIALIZED VIEW CONCURRENTLY v3.mv_expense_item_tree"))
+    except SQLAlchemyError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail=f"Не удалось обновить mv_expense_item_tree: {exc}",
+        ) from exc
+    return {"status": "ok", "message": "mv_expense_item_tree refreshed"}

api/src/api/v1/audit.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Depends, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.api.v1.deps import require_admin
+from src.db.session import get_db
+# from src.domain.models import Users
+from src.db.models.app_user import AppUser
+from src.domain.schemas import AuditLog, AuditLogQueryParams, BaseListResponse
+from src.services.auditlog_service import AuditLogService
+
+router = APIRouter(tags=["audit"])
+
+
+@router.get(
+    "/audit-logs",
+    response_model=BaseListResponse[AuditLog],
+    status_code=status.HTTP_200_OK,
+    summary="Получение журнала аудита",
+    description="Возвращает список записей аудита с возможностью фильтрации. Доступно только администраторам.",
+)
+async def get_audit_logs(
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(require_admin),
+    params: AuditLogQueryParams = Depends(),
+):
+    offset = (params.page - 1) * params.limit
+    audit_service = AuditLogService(db)
+
+    logs, count = await audit_service.get_all(
+        user=current_user,
+        limit=params.limit,
+        offset=offset,
+        user_id=params.user_id,
+        org_unit_id=params.org_unit_id,
+        task_id=params.task_id,
+        form_id=params.form_id,
+        event_type=params.event_type,
+        date_from=params.date_from,
+        date_to=params.date_to,
+    )
+    result = [audit_service.orm_log_to_response(log) for log in logs]
+    return BaseListResponse(result=result, count=count)

api/src/api/v1/deps.py

@@ -5,7 +5,8 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from src.core.config import settings
 from src.core.security import verify_token
 from src.db.session import get_db
-from src.domain.models import UserRole, Users
+from src.db.models.app_user import AppUser
+from src.db.models.role import UserRoleEnum
 from src.repository.user_repository import UserRepository
 
 security = HTTPBearer()
@@ -13,11 +14,10 @@ security = HTTPBearer()
 
 if settings.DEBUG:
 
-    async def get_current_user(
-        credentials: HTTPAuthorizationCredentials = Depends(security),
-        db: AsyncSession = Depends(get_db),
-    ) -> Users:
-        token = credentials.credentials
+    async def get_user_by_token(
+            token: str,
+            db: AsyncSession,
+    ) -> AppUser:
         payload = verify_token(token)
         if payload is None:
             raise HTTPException(
@@ -46,13 +46,19 @@ if settings.DEBUG:
             )
         return user
 
+    async def get_current_user(
+        credentials: HTTPAuthorizationCredentials = Depends(security),
+        db: AsyncSession = Depends(get_db),
+    ) -> AppUser:
+        return await get_user_by_token(token=credentials.credentials, db=db)
+
 else:
     from raisa_fastapi_protected_api import UserInfo, get_user_dependency
 
     async def get_current_user(
         user: UserInfo = Depends(get_user_dependency),
         db: AsyncSession = Depends(get_db),
-    ) -> Users:
+    ) -> AppUser:
         user_repo = UserRepository(db)
         db_user = await user_repo.get_by_email(user.email)
         if db_user is None:
@@ -64,12 +70,24 @@ else:
         return db_user
 
 
-async def get_current_active_user(current_user: Users = Depends(get_current_user)) -> Users:
+async def get_current_active_user(current_user: AppUser = Depends(get_current_user)) -> AppUser:
     return current_user
 
 
-def require_admin(current_user: Users = Depends(get_current_active_user)) -> Users:
-    if current_user.role_id != UserRole.ADMIN:
+async def get_current_active_user_with_set_db(
+        current_user: AppUser = Depends(get_current_user),
+        db: AsyncSession = Depends(get_db),
+) -> AppUser:
+    
+    user_repo = UserRepository(db)
+    await user_repo.set_app_user_id(current_user.id)
+    return current_user
+
+
+def require_admin(
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> AppUser:
+    if current_user.role_id != UserRoleEnum.ADMIN:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Недостаточно прав",
@@ -77,11 +95,13 @@ def require_admin(current_user: Users = Depends(get_current_active_user)) -> Use
     return current_user
 
 
-def require_executor(current_user: Users = Depends(get_current_active_user)) -> Users:
+def require_executor(
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> AppUser:
     if current_user.role_id not in [
-        UserRole.ADMIN,
-        UserRole.EXECUTOR_DFIP,
-        UserRole.EXECUTOR_RF,
+        UserRoleEnum.ADMIN,
+        UserRoleEnum.EXECUTOR_DFIP,
+        UserRoleEnum.EXECUTOR_RF,
     ]:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
@@ -90,8 +110,10 @@ def require_executor(current_user: Users = Depends(get_current_active_user)) ->
     return current_user
 
 
-def require_executor_dfip(current_user: Users = Depends(get_current_active_user)) -> Users:
-    if current_user.role_id not in [UserRole.ADMIN, UserRole.EXECUTOR_DFIP]:
+def require_executor_dfip(
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> AppUser:
+    if current_user.role_id not in [UserRoleEnum.ADMIN, UserRoleEnum.EXECUTOR_DFIP]:
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Недостаточно прав",

api/src/api/v1/export.py

@@ -0,0 +1,155 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.responses import StreamingResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.api.v1.deps import get_current_active_user_with_set_db
+from src.db.models.app_user import AppUser
+from src.db.session import get_db
+from src.domain.schemas import DirectionSchemaEnum, ExportBulkRequest
+from src.services.export_service import ExportService
+
+router = APIRouter(prefix="/export", tags=["export"])
+FORM3_ALLOWED_SECTIONS = {"q1", "q2", "q3", "q4", "year"}
+
+
+def _parse_sections_csv(sections: str | None) -> list[str] | None:
+    if sections is None:
+        return None
+    raw = [section.strip() for section in sections.split(",") if section.strip()]
+    normalized: list[str] = []
+    seen: set[str] = set()
+    quarter_tokens = {"q1", "q2", "q3", "q4", "totals"}
+    for section in raw:
+        if "." in section:
+            base_section, nested_section = section.split(".", 1)
+            nested_section = nested_section.strip()
+            tokens = [base_section.strip()]
+            if nested_section in quarter_tokens:
+                tokens.append(nested_section)
+            for token in tokens:
+                if token and token not in seen:
+                    seen.add(token)
+                    normalized.append(token)
+            continue
+        if section not in seen:
+            seen.add(section)
+            normalized.append(section)
+    return normalized or None
+
+
+def _parse_form3_sections_csv(sections: str | None) -> list[str] | None:
+    if not sections:
+        return None
+    parsed = [section.strip() for section in sections.split(",") if section.strip()]
+    invalid = sorted(set(parsed) - FORM3_ALLOWED_SECTIONS)
+    if invalid:
+        raise ValueError(f"Недопустимые sections для FORM_3: {', '.join(invalid)}")
+    return parsed
+
+
+@router.get("/form/{form_id}")
+async def export_form(
+    form_id: int,
+    direction: DirectionSchemaEnum | None = None,
+    sections: str | None = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+):
+    export_service = ExportService(db)
+    try:
+        stream, filename, media_type = await export_service.export_form_payload(
+            form_id=form_id,
+            current_user=current_user,
+            direction=direction.value if direction else None,
+            sections=_parse_sections_csv(sections),
+            ignore_non_applicable_query_params=True,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc))
+    return StreamingResponse(
+        stream,
+        media_type=media_type,
+        headers={"Content-Disposition": export_service.build_content_disposition(filename)},
+    )
+
+
+@router.get("/form/{form_id}/sheet/{sheet}")
+async def export_form_sheet(
+    form_id: int,
+    sheet: str,
+    direction: DirectionSchemaEnum | None = None,
+    sections: str | None = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+):
+    export_service = ExportService(db)
+    try:
+        stream, filename, media_type = await export_service.export_form_payload(
+            form_id=form_id,
+            current_user=current_user,
+            sheet=sheet,
+            direction=direction.value if direction else None,
+            sections=_parse_sections_csv(sections),
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc))
+    return StreamingResponse(
+        stream,
+        media_type=media_type,
+        headers={"Content-Disposition": export_service.build_content_disposition(filename)},
+    )
+
+
+@router.post("/bulk")
+async def export_forms_bulk(
+    payload: ExportBulkRequest,
+    direction: DirectionSchemaEnum | None = None,
+    sections: str | None = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+):
+    export_service = ExportService(db)
+    try:
+        stream, filename, media_type = await export_service.export_bulk_payload(
+            form_ids=payload.form_ids,
+            current_user=current_user,
+            skip_failed=payload.skip_failed,
+            direction=direction.value if direction else None,
+            sections=_parse_sections_csv(sections),
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc))
+    return StreamingResponse(
+        stream,
+        media_type=media_type,
+        headers={"Content-Disposition": export_service.build_content_disposition(filename)},
+    )
+
+
+@router.get("/project/{project_id}/report/{year}/{report_type}")
+async def export_project_report(
+    project_id: int,
+    year: int,
+    report_type: str,
+    sections: str | None = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+):
+    export_service = ExportService(db)
+    try:
+        stream, filename, media_type = await export_service.export_project_report_payload(
+            project_id=project_id,
+            year=year,
+            report_type=report_type,
+            current_user=current_user,
+            sections=_parse_form3_sections_csv(sections),
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc))
+    return StreamingResponse(
+        stream,
+        media_type=media_type,
+        headers={"Content-Disposition": export_service.build_content_disposition(filename)},
+    )
+
+

api/src/api/v1/form_phases.py

@@ -0,0 +1,113 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.app_user import AppUser
+from src.domain.schemas import (
+    BaseListResponse,
+    BaseSingleResponse,
+    FormPhaseCreate,
+    FormPhaseResponse,
+    FormPhaseUpdate,
+)
+from src.services.budget_form_service import BudgetFormService
+from src.services.form_phase_service import FormPhaseService
+from src.api.v1.deps import (
+    get_current_active_user_with_set_db,
+    require_admin,
+)
+from src.db.session import get_db
+
+router = APIRouter(prefix="/stages", tags=["stages"])
+
+
+@router.get("/form/{form_id}")
+async def get_form_phases(
+    form_id: int,
+    sheet: str | None = None,
+    phase_code: str | None = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[FormPhaseResponse]:
+    fp_service = FormPhaseService(db)
+    phases = await fp_service.get_list(
+        budget_form_id=form_id,
+        user=current_user,
+        sheet=sheet,
+        phase_code=phase_code,
+    )
+    return BaseListResponse(
+        result=[FormPhaseResponse.model_validate(p) for p in phases],
+        count=len(phases),
+    )
+
+
+@router.post("/form/{form_id}")
+async def create_form_phase(
+        form_id: int,
+        body: FormPhaseCreate,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(require_admin),
+) -> BaseSingleResponse[FormPhaseResponse]:
+    bf_service = BudgetFormService(db)
+    form = await bf_service.get(budget_form_id=form_id, user=current_user, load_form_type=True)
+    if not form:
+        raise HTTPException(404, "Форма не найдена")
+
+    fp_service = FormPhaseService(db)
+    phase = await fp_service.create(
+        budget_form=form, 
+        body=body, 
+        user=current_user,
+    )
+    return BaseSingleResponse(result=FormPhaseResponse.model_validate(phase))
+
+
+@router.patch("/form/{form_id}/{sheet}/{phase_code}")
+async def update_form_phase(
+    form_id: int,
+    sheet: str,
+    phase_code: str,
+    body: FormPhaseUpdate,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(require_admin),
+) -> BaseSingleResponse[FormPhaseResponse]:
+    bf_service = BudgetFormService(db)
+    form = await bf_service.get(budget_form_id=form_id, user=current_user, load_form_type=True)
+    if not form:
+        raise HTTPException(404, "Форма не найдена")
+    
+    fp_service = FormPhaseService(db)
+    phase = await fp_service.update(
+        budget_form=form,
+        sheet=sheet,
+        phase_code=phase_code,
+        body=body,
+        user=current_user,
+    )
+    if not phase:
+        raise HTTPException(404, "Этап не найден")
+    return BaseSingleResponse(result=FormPhaseResponse.model_validate(phase))
+
+
+@router.delete("/form/{form_id}/{sheet}/{phase_code}")
+async def delete_form_phase(
+    form_id: int,
+    sheet: str,
+    phase_code: str,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(require_admin),
+):
+    bf_service = BudgetFormService(db)
+    form = await bf_service.get(budget_form_id=form_id, user=current_user)
+    if not form:
+        raise HTTPException(404, "Форма не найдена")
+    
+    fp_service = FormPhaseService(db)
+    deleted = await fp_service.delete(
+        budget_form_id=form_id,
+        sheet=sheet,
+        phase_code=phase_code,
+        user=current_user,
+    )
+    if not deleted:
+        raise HTTPException(404, "Этап не найден")

api/src/api/v1/forms.py

@@ -0,0 +1,356 @@
+import time
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Response
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.services.budget_line_service import BudgetLineService
+from src.db.models.form_type import FormTypeEnum
+from src.services.sheet_service import SheetService
+from src.domain.schemas import AddLineSchema, BaseListResponse, BaseSingleResponse, BudgetFormResponse, CellPatch, CellsPatch, DirectionSchemaEnum, SheetFormTypeResponse, SheetResponse
+from src.db.models.app_user import AppUser
+from src.services.budget_form_service import BudgetFormService
+from src.api.v1.deps import get_current_active_user_with_set_db
+from src.db.session import get_db
+
+router = APIRouter(prefix="/form", tags=["forms"])
+SHEETS_WITH_SECTIONS = {"AHR", "CAP", "OPER"}
+FORM1_DIRECTION_REQUIRED_SHEETS = {"AHR", "CAP"}
+
+
+def _rows_to_sheet_response(result: list[tuple]) -> list[SheetResponse]:
+    return [
+        SheetResponse(
+            row_type=el[0],
+            depth=el[1],
+            sort_order=el[2],
+            data=el[3],
+        ) for el in result
+    ]
+
+
+def _parse_sections_csv(sections: Optional[str]) -> Optional[list[str]]:
+    if sections is None:
+        return None
+    parsed = [section.strip() for section in sections.split(",") if section.strip()]
+    return parsed or None
+
+
+def _validate_sheet_query_params(
+    form_type_code: FormTypeEnum,
+    sheet: str,
+    direction: Optional[DirectionSchemaEnum],
+    sections: Optional[list[str]],
+) -> None:
+    if form_type_code == FormTypeEnum.FORM_1 and sheet in FORM1_DIRECTION_REQUIRED_SHEETS and not direction:
+        raise HTTPException(400, "direction обязателен для FORM_1 листов AHR/CAP")
+
+    if direction and not (
+        form_type_code == FormTypeEnum.FORM_1 and sheet in FORM1_DIRECTION_REQUIRED_SHEETS
+    ):
+        raise HTTPException(400, "direction допустим только для FORM_1 листов AHR/CAP")
+
+    if sections and sheet not in SHEETS_WITH_SECTIONS:
+        raise HTTPException(400, f"sections не поддерживается для листа {sheet}")
+
+
+@router.get("/")
+async def get_forms(
+    offset: int = 0,
+    limit: int = 100,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[BudgetFormResponse]:
+    """Все строки v3.budget_form для UI-выпадашки."""
+    bf_service = BudgetFormService(db)
+    count, forms = await bf_service.get_list(
+        user=current_user, 
+        with_count=True,
+        offset=offset,
+        limit=limit,
+        load_org=True,
+    )
+    return BaseListResponse(
+        result = [
+            BudgetFormResponse.model_validate(form) for form in forms
+        ],
+        count=count,
+    )
+
+
+@router.get("/{form_id}")
+async def get_form(
+    form_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseSingleResponse[BudgetFormResponse]:
+    bf_service = BudgetFormService(db)
+    form = await bf_service.get(
+        user=current_user, 
+        budget_form_id=form_id,
+        load_org=True,
+    )
+    return BaseSingleResponse(
+        result = BudgetFormResponse.model_validate(form),
+    )
+
+
+@router.get("/{form_id}/sheets")
+async def get_form_sheets(
+    form_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseSingleResponse[SheetFormTypeResponse]:
+    bf_service = BudgetFormService(db)
+    form = await bf_service.get(budget_form_id=form_id, user=current_user, load_form_type=True)
+
+    if not form:
+        raise HTTPException(404, f"Форма {form_id} не найдена")
+    return BaseSingleResponse(
+        result=SheetFormTypeResponse(
+            form_type=form.form_type.code,
+            sheets=form.form_type.sheet_list,
+            all_sheets=form.form_type.sheet_list_with_directions,
+        )
+    )
+
+
+@router.get("/{form_id}/sheet/{sheet}")
+async def get_sheet(
+        form_id: int, 
+        sheet: str, 
+        response: Response,
+        direction: Optional[DirectionSchemaEnum] = None,
+        sections: Optional[str] = None,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[SheetResponse]:
+    sections = _parse_sections_csv(sections)
+    t0 = time.perf_counter()
+    bf_service = BudgetFormService(db)
+    sheet_service = SheetService(db)
+
+    form = await bf_service.get(
+        user=current_user,
+        budget_form_id=form_id,
+        load_form_type=True,
+    )
+    if not form:
+        raise HTTPException(404, f"Форма {form_id} не найдена")
+    if sheet not in form.form_type.sheet_list:
+        raise HTTPException(404, f"Лист {sheet} формы {form_id} не найден")
+    _validate_sheet_query_params(form.form_type.code, sheet, direction, sections)
+    if sections and (rem_sects := set(sections) - set(form.form_type.section_list)):
+        raise HTTPException(400, f"Недопустимые sections: {', '.join(sorted(rem_sects))}")
+
+    result = await sheet_service.get(
+        form_id=form_id,
+        sheet=sheet,
+        direction=direction.value if direction else None,
+        sections=sections,
+    )
+    db_ms = (time.perf_counter() - t0) * 1000
+    response.headers["X-DB-Time-Ms"] = f"{db_ms:.2f}"
+    return BaseListResponse(
+            count=len(result),
+            result=_rows_to_sheet_response(result),
+        )
+
+
+@router.patch("/{form_id}/sheet/{sheet}/cell")
+async def update_cell(
+        form_id: int, 
+        sheet: str, 
+        response: Response,
+        cell_body: CellPatch,
+        direction: Optional[DirectionSchemaEnum] = None,
+        sections: Optional[str] = None,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[SheetResponse]:
+    sections = _parse_sections_csv(sections)
+    t0 = time.perf_counter()
+    bf_service = BudgetFormService(db)
+    sheet_service = SheetService(db)
+
+    form = await bf_service.get(
+        user=current_user,
+        budget_form_id=form_id,
+        load_form_type=True,
+    )
+    if not form:
+        raise HTTPException(404, f"Форма {form_id} не найдена")
+    if sheet not in form.form_type.sheet_list:
+        raise HTTPException(404, f"Лист {sheet} формы {form_id} не найден")
+    _validate_sheet_query_params(form.form_type.code, sheet, direction, sections)
+    if sections and (rem_sects := set(sections) - set(form.form_type.section_list)):
+        raise HTTPException(400, f"Недопустимые sections: {', '.join(sorted(rem_sects))}")
+
+    budget_line_service = BudgetLineService(db)
+    budget_line = await budget_line_service.get(budget_line_id=cell_body.line_id, user=current_user)
+    if budget_line.budget_form_id != form_id:
+        raise HTTPException(404, f"Строка формы не найдена")
+    
+
+    result = await sheet_service.update_cell(
+        form_id=form_id, 
+        sheet=sheet,
+        direction=direction.value if direction else None,
+        sections=sections,
+        line_id=cell_body.line_id, 
+        column=cell_body.column, 
+        value=cell_body.value, 
+        user=current_user,
+    )
+    db_ms = (time.perf_counter() - t0) * 1000
+    response.headers["X-DB-Time-Ms"] = f"{db_ms:.2f}"
+    return BaseListResponse(
+            count=len(result),
+            result=_rows_to_sheet_response(result),
+        )
+
+
+
+
+@router.patch("/{form_id}/sheet/{sheet}/cells")
+async def update_cells(
+        form_id: int, 
+        sheet: str, 
+        response: Response,
+        cells_body: CellsPatch,
+        direction: Optional[DirectionSchemaEnum] = None,
+        sections: Optional[str] = None,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[SheetResponse]:
+    sections = _parse_sections_csv(sections)
+    t0 = time.perf_counter()
+    bf_service = BudgetFormService(db)
+    sheet_service = SheetService(db)
+
+    form = await bf_service.get(
+        user=current_user,
+        budget_form_id=form_id,
+        load_form_type=True,
+    )
+    if not form:
+        raise HTTPException(404, f"Форма {form_id} не найдена")
+    if sheet not in form.form_type.sheet_list:
+        raise HTTPException(404, f"Лист {sheet} формы {form_id} не найден")
+    _validate_sheet_query_params(form.form_type.code, sheet, direction, sections)
+    if sections and (rem_sects := set(sections) - set(form.form_type.section_list)):
+        raise HTTPException(400, f"Недопустимые sections: {', '.join(sorted(rem_sects))}")
+
+    budget_line_service = BudgetLineService(db)
+    budget_lines = await budget_line_service.get_list(
+        budget_line_ids=[cb.line_id for cb in cells_body.changes], user=current_user)
+    for budget_line in budget_lines:
+        if budget_line.budget_form_id != form_id:
+            raise HTTPException(404, f"Строка формы не найдена")
+    
+
+    result = await sheet_service.update_cells(
+        form_id=form_id, 
+        sheet=sheet,
+        direction=direction.value if direction else None,
+        sections=sections,
+        changes=[c.model_dump() for c in cells_body.changes],
+        user=current_user,
+    )
+    db_ms = (time.perf_counter() - t0) * 1000
+    response.headers["X-DB-Time-Ms"] = f"{db_ms:.2f}"
+    return BaseListResponse(
+            count=len(result),
+            result=_rows_to_sheet_response(result),
+    )
+
+
+
+@router.post("/{form_id}/sheet/{sheet}/line")
+async def add_line(
+        form_id: int, 
+        sheet: str, 
+        body: AddLineSchema,
+        response: Response,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(get_current_active_user_with_set_db),
+):
+    t0 = time.perf_counter()
+    bf_service = BudgetFormService(db)
+    sheet_service = SheetService(db)
+
+    form = await bf_service.get(
+        user=current_user,
+        budget_form_id=form_id,
+        load_form_type=True,
+    )
+    if not form:
+        raise HTTPException(404, f"Форма {form_id} не найдена")
+    if sheet not in form.form_type.sheet_list:
+        raise HTTPException(404, f"Лист {sheet} формы {form_id} не найден")
+    _validate_sheet_query_params(form.form_type.code, sheet, body.direction, None)
+
+    result = await sheet_service.add_line(
+        form_id=form_id,
+        sheet=sheet,
+        expense_item_id=body.expense_item_id,
+        item_id=body.item_id,
+        section_code=body.section_code,
+        direction=body.direction.value if body.direction else None,
+        name=body.name,
+        internal_order=body.internal_order,
+        vsp_id=body.vsp_id,
+        project_id=body.project_id,
+        justification=body.justification,
+        contract_number=body.contract_number,
+        contract_end_date=body.contract_end_date,
+        user=current_user,
+    )
+    db_ms = (time.perf_counter() - t0) * 1000
+    response.headers["X-DB-Time-Ms"] = f"{db_ms:.2f}"
+    return BaseListResponse(
+            count=len(result),
+            result=_rows_to_sheet_response(result),
+    )
+
+
+
+@router.delete("/{form_id}/sheet/{sheet}/line/{row_id}")
+async def delete_line(
+        form_id: int, 
+        sheet: str, 
+        row_id: int,
+        response: Response,
+        direction: Optional[DirectionSchemaEnum] = None,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(get_current_active_user_with_set_db),
+):
+    t0 = time.perf_counter()
+    sheet_service = SheetService(db)
+    bf_service = BudgetFormService(db)
+
+    form = await bf_service.get(
+        user=current_user,
+        budget_form_id=form_id,
+        load_form_type=True,
+    )
+    if not form:
+        raise HTTPException(404, f"Форма {form_id} не найдена")
+    if sheet not in form.form_type.sheet_list:
+        raise HTTPException(404, f"Лист {sheet} формы {form_id} не найден")
+    _validate_sheet_query_params(form.form_type.code, sheet, direction, None)
+    
+    result = await sheet_service.delete_line(
+        form_id=form_id,
+        sheet=sheet,
+        row_id=row_id,
+        direction=direction.value if direction else None,
+        user=current_user,
+    )
+    db_ms = (time.perf_counter() - t0) * 1000
+    response.headers["X-DB-Time-Ms"] = f"{db_ms:.2f}"
+    return BaseListResponse(
+        count=len(result),
+        result=_rows_to_sheet_response(result),
+    )

api/src/api/v1/org_unit.py

@@ -0,0 +1,125 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.core.errors import AccessDeniedException
+from src.api.v1.deps import get_current_active_user, require_admin
+from src.db.models.app_user import AppUser
+from src.db.session import get_db
+from src.domain.schemas import BaseListResponse, BaseSingleResponse, OrgUnitBaseSchema, OrgUnitListSchema, OrgUnitSchema, OrgUnitUpdateSchema, ResponseBase
+from src.services.org_unit_service import OrgUnitService
+
+
+
+router = APIRouter(prefix="/org-unit", tags=["ssp"])
+
+
+@router.get("/")
+async def org_unit_list(
+        offset: int = 0,
+        limit: int = 100,
+        is_active: bool | None = None,
+        is_ssp: bool | None = None,
+        load_users_count: bool = False,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(require_admin),
+) -> BaseListResponse[OrgUnitListSchema]:
+    org_service = OrgUnitService(db)
+    count, units = await org_service.get_list(
+        user=current_user, 
+        with_count=True,
+        offset=offset,
+        limit=limit,
+        load_users=load_users_count,
+        is_active=is_active,
+        is_ssp=is_ssp,
+
+    )
+    return BaseListResponse(
+        result=[
+            OrgUnitListSchema.model_validate(unit) for unit in units
+        ],
+        count=count,
+    )
+
+
+@router.get("/{org_unit_id}")
+async def org_unit_id(
+        org_unit_id: int,
+        load_users: bool = False,
+        db: AsyncSession = Depends(get_db),
+        current_user: AppUser = Depends(require_admin),
+) -> BaseSingleResponse[OrgUnitSchema]:
+    org_service = OrgUnitService(db)
+    unit = await org_service.get(
+        user=current_user,
+        org_unit_id=org_unit_id,
+        load_users=load_users,
+    )
+    if not unit:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="ССП не найден")
+
+    return BaseSingleResponse(
+        result = OrgUnitSchema.model_validate(unit)
+    )
+
+
+@router.post("/")
+async def create_ssp(
+    org_data: OrgUnitBaseSchema,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(require_admin),
+) -> BaseSingleResponse[OrgUnitSchema]:
+    """Создание ССП/РФ."""
+    org_unit_service = OrgUnitService(db)
+    org_unit = await org_unit_service.create(
+        title=org_data.title, 
+        is_ssp=org_data.is_ssp, 
+        user=current_user,
+    )
+    return BaseSingleResponse(
+        message="ССП/РФ создана",
+        result=OrgUnitSchema.model_validate(org_unit),
+    )
+
+
+@router.patch("/{org_unit_id}")
+async def update_ssp(
+    org_unit_id: int,
+    org_data: OrgUnitUpdateSchema,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(require_admin),
+) -> BaseSingleResponse[OrgUnitSchema]:
+    """Редактирование ССП/РФ."""
+    org_unit_service = OrgUnitService(db)
+    org_unit = await org_unit_service.update(
+        org_unit_id=org_unit_id,
+        user=current_user,
+        **org_data.model_dump(exclude_unset=True),
+    )
+    if not org_unit:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="ССП не найден")
+
+    return BaseSingleResponse(
+        message="ССП/РФ обновлена",
+        result=OrgUnitSchema.model_validate(org_unit),
+    )
+
+
+@router.delete("/{org_unit_id}")
+async def delete_ssp(
+    org_unit_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(require_admin),
+) -> ResponseBase:
+    """Удаление ССП/РФ."""
+    org_unit_service = OrgUnitService(db)
+    result = await org_unit_service.logical_delete(
+        org_unit_id=org_unit_id, 
+        user=current_user,
+        is_active=True,
+    )
+    if not result:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="ССП не найден")
+
+    return ResponseBase(success=True, message="ССП/РФ удалена")

api/src/api/v1/projects.py

@@ -0,0 +1,247 @@
+import time
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Response
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.api.v1.deps import get_current_active_user_with_set_db
+from src.db.models.app_user import AppUser
+from src.db.session import get_db
+from src.domain.schemas import (
+    AddForm3LineBody,
+    AddProjectBody,
+    BaseListResponse,
+    BaseSingleResponse,
+    CellPatch,
+    CellsPatch,
+    SheetResponse,
+    UpdProjectBody,
+)
+from src.services.project_service import ProjectService
+
+
+router = APIRouter(tags=["forms"])
+FORM3_ALLOWED_SECTIONS = {"q1", "q2", "q3", "q4", "year"}
+
+
+def _parse_sections(sections: Optional[str]) -> Optional[list[str]]:
+    if not sections:
+        return None
+    parsed = [s.strip() for s in sections.split(",") if s.strip()]
+    invalid = sorted(set(parsed) - FORM3_ALLOWED_SECTIONS)
+    if invalid:
+        raise HTTPException(400, f"Недопустимые sections для FORM_3: {', '.join(invalid)}")
+    return parsed
+
+
+def _rows_to_payload(rows: list[tuple]) -> list[dict]:
+    return [
+        {"row_type": row[0], "depth": row[1], "sort_order": row[2], "data": row[3]}
+        for row in rows
+    ]
+
+
+@router.get("/projects")
+async def get_projects(
+    offset: int = 0,
+    limit: int = 100,
+    year: Optional[int] = None,
+    branch_id: Optional[int] = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[dict]:
+    project_service = ProjectService(db)
+    count, projects = await project_service.get_list(
+        user=current_user,
+        with_count=True,
+        year=year,
+        branch_id=branch_id,
+        offset=offset,
+        limit=limit,
+    )
+    return BaseListResponse(result=projects, count=count)
+
+
+@router.get("/projects/{project_id}")
+async def get_project(
+    project_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseSingleResponse[dict]:
+    project_service = ProjectService(db)
+    project = await project_service.get(project_id=project_id, user=current_user)
+    if not project:
+        raise HTTPException(404, "Project not found")
+    return BaseSingleResponse(result=project)
+
+
+@router.get("/projects/{project_id}/report/{year}/{report_type}")
+async def get_project_report(
+    project_id: int,
+    year: int,
+    report_type: str,
+    response: Response,
+    sections: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[SheetResponse]:
+    project_service = ProjectService(db)
+    t0 = time.perf_counter()
+    rows = await project_service.get_report_rows(
+        project_id=project_id,
+        year=year,
+        report_type=report_type,
+        sections=_parse_sections(sections),
+        user=current_user,
+    )
+    db_ms = (time.perf_counter() - t0) * 1000
+    response.headers["X-DB-Time-Ms"] = f"{db_ms:.2f}"
+    return BaseListResponse(count=len(rows), result=_rows_to_payload(rows))
+
+
+@router.get("/rf-rollup/{branch_id}/{year}")
+async def get_rf_rollup(
+    branch_id: int,
+    year: int,
+    response: Response,
+    sections: Optional[str] = None,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> BaseListResponse[SheetResponse]:
+    project_service = ProjectService(db)
+    t0 = time.perf_counter()
+    rows = await project_service.get_rf_rollup_rows(
+        branch_id=branch_id,
+        year=year,
+        sections=_parse_sections(sections),
+        user=current_user,
+    )
+    db_ms = (time.perf_counter() - t0) * 1000
+    response.headers["X-DB-Time-Ms"] = f"{db_ms:.2f}"
+    return BaseListResponse(count=len(rows), result=_rows_to_payload(rows))
+
+
+@router.patch("/projects/{project_id}/report/{year}/{report_type}/cell")
+async def upd_form3_cell(
+    project_id: int,
+    year: int,
+    report_type: str,
+    body: CellPatch,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> list[SheetResponse]:
+    project_service = ProjectService(db)
+    rows = await project_service.upd_form3_cell(
+        project_id=project_id,
+        year=year,
+        report_type=report_type,
+        line_id=body.line_id,
+        column=body.column,
+        value=body.value,
+        user=current_user,
+    )
+    return _rows_to_payload(rows)
+
+
+@router.patch("/projects/{project_id}/report/{year}/{report_type}/cells")
+async def upd_form3_cells(
+    project_id: int,
+    year: int,
+    report_type: str,
+    body: CellsPatch,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> list[SheetResponse]:
+    project_service = ProjectService(db)
+    rows = await project_service.upd_form3_cells(
+        project_id=project_id,
+        year=year,
+        report_type=report_type,
+        changes=[change.model_dump() for change in body.changes],
+        user=current_user,
+    )
+    return _rows_to_payload(rows)
+
+
+@router.post("/projects/{project_id}/report/{year}/{report_type}/line")
+async def add_form3_line(
+    project_id: int,
+    year: int,
+    report_type: str,
+    body: AddForm3LineBody,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> list[SheetResponse]:
+    project_service = ProjectService(db)
+    rows = await project_service.add_form3_line(
+        project_id=project_id,
+        year=year,
+        report_type=report_type,
+        expense_item_id=body.expense_item_id,
+        user=current_user,
+    )
+    return _rows_to_payload(rows)
+
+
+@router.delete("/projects/{project_id}/report/{year}/{report_type}/line/{line_id}")
+async def del_form3_line(
+    project_id: int,
+    year: int,
+    report_type: str,
+    line_id: int,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> list[SheetResponse]:
+    project_service = ProjectService(db)
+    rows = await project_service.del_form3_line(
+        project_id=project_id,
+        year=year,
+        report_type=report_type,
+        line_id=line_id,
+        user=current_user,
+    )
+    return _rows_to_payload(rows)
+
+
+@router.patch("/project/{project_id}")
+async def upd_project(
+    project_id: int,
+    body: UpdProjectBody,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> dict:
+    project_service = ProjectService(db)
+    result = await project_service.upd_project(
+        project_id=project_id,
+        column=body.column,
+        value=body.value,
+        user=current_user,
+    )
+    return result
+
+
+@router.post("/projects")
+async def add_project(
+    body: AddProjectBody,
+    db: AsyncSession = Depends(get_db),
+    current_user: AppUser = Depends(get_current_active_user_with_set_db),
+) -> dict:
+    project_service = ProjectService(db)
+    project_id, limit_report_id, current_expenses_report_id = await project_service.add_project(
+        name=body.name,
+        year=body.year,
+        org_unit_id=body.branch_id,
+        level=body.level,
+        parent_id=body.parent_id,
+        project_type=body.project_type,
+        vsp_format=body.vsp_format,
+        placement_type=body.placement_type,
+        object_address=body.object_address,
+        staff_count=body.staff_count,
+        total_area=body.total_area,
+    )
+    return {
+        "project_id": project_id,
+        "limit_report_id": limit_report_id,
+        "current_expenses_report_id": current_expenses_report_id,
+    }

api/src/api/v1/router.py

@@ -1,7 +1,18 @@
 from fastapi import APIRouter
 
-from src.api.v1 import auth, users
+from src.api.v1 import auth, users, admin, audit, forms, form_phases, projects, export, org_unit
+
+from src.api.v1 import websocket
+
 
 api_router = APIRouter()
 api_router.include_router(auth.router)
 api_router.include_router(users.router)
+api_router.include_router(admin.router)
+api_router.include_router(audit.router)
+api_router.include_router(forms.router)
+api_router.include_router(projects.router)
+api_router.include_router(form_phases.router)
+api_router.include_router(export.router)
+api_router.include_router(websocket.router)
+api_router.include_router(org_unit.router)

api/src/api/v1/users.py

@@ -1,10 +1,14 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from src.api.v1.deps import get_current_active_user, require_admin, require_executor_dfip
+from src.api.v1.deps import (
+    get_current_active_user,
+    require_admin,
+    require_executor_dfip,
+)
 from src.db.session import get_db
-from src.domain.models import Users
-from src.domain.schemas import User as UserSchema
+from src.db.models.app_user import AppUser
+from src.domain.schemas import BaseListResponse, BaseSingleResponse, User as UserSchema, UserAdminListResponse
 from src.domain.schemas import (
     SSPIDList,
     ResponseBase,
@@ -21,27 +25,38 @@ router = APIRouter(prefix="/users", tags=["users"])
 
 
 @router.get("/me", response_model=UserSchema)
-async def get_current_user_info(current_user: Users = Depends(get_current_active_user)):
+async def get_current_user_info(current_user: AppUser = Depends(get_current_active_user)):
     return current_user
 
 
-@router.get("/", response_model=UserListResponse)
+@router.get("/")
 async def get_users(
     skip: int = 0,
     limit: int = 100,
+    load_orgs: bool = False,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_admin),
-):
+    current_user: AppUser = Depends(require_admin),
+) -> BaseListResponse[UserAdminListResponse]:
     user_service = UserService(db)
-    users = await user_service.get_all(current_user, skip=skip, limit=limit)
-    return UserListResponse(success=True, message="Список пользователей", result=users)
+    count, users = await user_service.get_all(
+        current_user, 
+        skip=skip, 
+        limit=limit, 
+        load_orgs=load_orgs,
+        with_count=True
+    )
+
+    return BaseListResponse(
+        count=count,
+        result=[UserAdminListResponse.model_validate(user) for user in users]
+    )
 
 
 @router.get("/dfip-many-ssp/", response_model=UserSSPLinkResponse)
 async def get_many_ssp(
     user_id: int,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_executor_dfip),
+    current_user: AppUser = Depends(require_executor_dfip),
 ):
     user_service = UserService(db)
     ssp_list = await user_service.get_many_ssp(user_id, current_user)
@@ -57,7 +72,7 @@ async def set_many_ssp(
     user_id: int,
     ssp_ids_data: SSPIDList,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_admin),
+    current_user: AppUser = Depends(require_admin),
 ):
     user_service = UserService(db)
     success = await user_service.set_many_ssp(user_id, ssp_ids_data.ssp_ids, current_user)
@@ -72,7 +87,7 @@ async def unset_many_ssp(
     user_id: int,
     ssp_ids_data: SSPIDList,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_admin),
+    current_user: AppUser = Depends(require_admin),
 ):
     user_service = UserService(db)
     success = await user_service.unset_many_ssp(
@@ -84,39 +99,50 @@ async def unset_many_ssp(
     )
 
 
-@router.get("/{user_id}", response_model=UserSchema)
+@router.get("/{user_id}")
 async def get_user(
     user_id: int,
+    load_orgs: bool = False,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_admin),
-):
+    current_user: AppUser = Depends(require_admin),
+) -> UserAdminListResponse:
     user_service = UserService(db)
-    user = await user_service.get(user_id, current_user)
+    user = await user_service.get(
+        user_id=user_id, 
+        current_user=current_user,
+        load_orgs=load_orgs,
+    )
     if not user:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail="Пользователь не найден",
         )
-    return user
+    return UserAdminListResponse.model_validate(user)
 
 
-@router.put("/", response_model=UserResponse)
+
+@router.post("/", response_model=BaseSingleResponse[UserAdminListResponse])
 async def create_user(
     user_data: UserCreate,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_admin),
+    current_user: AppUser = Depends(require_admin),
 ):
     user_service = UserService(db)
     user = await user_service.create_user(user_data=user_data, creator=current_user)
-    return UserResponse(success=True, message="Пользователь создан", result=user)
+
+    result = UserAdminListResponse.model_validate(user)
+    if user_data.load_orgs:
+        result.org_units = []
+
+    return BaseSingleResponse(success=True, message="Пользователь создан", result=result)
 
 
-@router.patch("/{user_id}", response_model=UserResponse)
+@router.patch("/{user_id}", response_model=BaseSingleResponse[UserAdminListResponse])
 async def update_user(
     user_id: int,
     user_data: UserUpdate,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_admin),
+    current_user: AppUser = Depends(require_admin),
 ):
     user_service = UserService(db)
     user = await user_service.update_user(
@@ -124,14 +150,15 @@ async def update_user(
         user_data=user_data,
         user=current_user,
     )
-    return UserResponse(success=True, message="Пользователь обновлен", result=user)
+    result = UserAdminListResponse.model_validate(user)
+    return UserResponse(success=True, message="Пользователь обновлен", result=result)
 
 
 @router.delete("/{user_id}", response_model=UserResponse)
 async def delete_user(
     user_id: int,
     db: AsyncSession = Depends(get_db),
-    current_user: Users = Depends(require_admin),
+    current_user: AppUser = Depends(require_admin),
 ):
     user_service = UserService(db)
     await user_service.delete_user(user_id=user_id, user=current_user)

api/src/api/v1/websocket.py

@@ -0,0 +1,844 @@
+from contextlib import asynccontextmanager
+from dataclasses import asdict
+import dataclasses
+import enum
+from json import dumps, loads
+from typing import Any, Optional
+
+#
+from asyncpg import UniqueViolationError
+from sqlalchemy.exc import IntegrityError
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.services.budget_line_service import BudgetLineService
+from src.api.v1.deps import get_user_by_token
+from src.db.models.app_user import AppUser
+from src.db.models.form_type import FormTypeEnum
+from src.services.budget_form_service import BudgetFormService
+from src.services.project_service import ProjectService
+from src.services.sheet_service import SheetService
+from src.core.errors import BasicAppException, ValidationsError
+from src.db.session import SessionLocal
+
+from src.services.user_service import UserService
+
+
+@asynccontextmanager
+async def get_db_session():
+    """Контекстный менеджер для получения сессии базы данных."""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        await db.close()
+
+
+router = APIRouter(prefix="/ws", tags=["websocket"])
+
+
+@dataclasses.dataclass
+class ConnectionInfo:
+    ws: WebSocket
+    user_id: int | None
+
+
+@dataclasses.dataclass
+class FormConnectionInfo(ConnectionInfo):
+    form_id: int | None = None
+    sheet: str | None = None
+    direction: str | None = None
+
+
+@dataclasses.dataclass
+class ProjectConnectionInfo(ConnectionInfo):
+    project_id: int | None = None
+    year: int | None = None
+    report_type: str | None = None
+
+
+class ConnectionKeyEnum(str, enum.Enum):
+    FORM = "FORM"
+    PROJECT = "PROJECT"
+
+
+class ConnectionManager:
+    con_info_mapping = {
+        ConnectionKeyEnum.FORM: FormConnectionInfo,
+        ConnectionKeyEnum.PROJECT: ProjectConnectionInfo,
+    }
+
+    def __init__(self):
+        self.connections: dict[int, dict[ConnectionKeyEnum, list[ConnectionInfo]]] = {
+            ConnectionKeyEnum.FORM: {},
+            ConnectionKeyEnum.PROJECT: {},
+        }
+        self.cell_locks: dict[Any, int] = {}
+        
+
+    async def connect(
+            self, 
+            websocket: WebSocket,
+            con_key: ConnectionKeyEnum,
+            **kwargs,
+            # form_id: int, 
+            # sheet: str, 
+            # direction: str | None = None,
+    ):
+        await websocket.accept()
+
+        key = frozenset(kwargs.items())
+        cls = self.con_info_mapping[con_key]
+
+        if key not in self.connections[con_key]:
+            self.connections[con_key][key] = [
+                cls(
+                    ws=websocket, 
+                    user_id=None,
+                    **kwargs,
+                )
+            ]
+        else:
+            self.connections[con_key][key].append(
+                cls(
+                    ws=websocket,
+                    user_id=None,
+                    **kwargs,
+                )
+            
+            )
+    
+    def set_user(
+            self, 
+            websocket: WebSocket, 
+            user_id: int, 
+            con_key: ConnectionKeyEnum,
+            **kwargs,
+    ):
+        key = frozenset(kwargs.items())
+
+        if key not in self.connections[con_key]:
+            return
+        for con_info in self.connections[con_key][key]:
+            if con_info.ws == websocket:
+                con_info.user_id = user_id
+
+    async def disconnect(
+            self, 
+            websocket: WebSocket, 
+            con_key: ConnectionKeyEnum,
+            code: int = status.WS_1008_POLICY_VIOLATION,
+            reason: str = "Ошибка",
+            **kwargs,
+    ):
+        key = frozenset(kwargs.items())
+
+        if key not in self.connections[con_key]:
+            return
+        for con_info in self.connections[con_key][key]:
+            if con_info.ws == websocket:
+                self.connections[con_key][key].remove(con_info)
+        if not len(self.connections[con_key][key]):
+            del self.connections[con_key][key]
+        
+        self.release_locks_for_user(con_key=con_key, user_id=con_info.user_id, form_key=kwargs)
+        await websocket.close(
+            code=code, reason=reason,
+        )
+    
+    async def broadcast_to_other(
+            self, 
+            message: str, 
+            user_id: int,
+            con_key: ConnectionKeyEnum,
+            **kwargs,
+    ):
+        key = frozenset(kwargs.items())
+
+        if key not in self.connections[con_key]:
+            return
+        
+        for con_info in self.connections[con_key][key]:
+            if con_info.user_id != user_id:
+                try:
+                    await con_info.ws.send_text(message)
+                except:
+                    pass  # Игнорируем недоступные соединения
+
+    async def broadcast_to_all(
+            self, 
+            message: str,  
+            con_key: ConnectionKeyEnum,
+            **kwargs,
+    ):
+        key = frozenset(kwargs.items())
+        if key not in self.connections[con_key]:
+            return
+        for con_info in self.connections[con_key][key]:
+            try:
+                await con_info.ws.send_text(message)
+            except:
+                pass  # Игнорируем недоступные соединения
+
+    async def send_back(self, message: str, websocket: WebSocket):
+        await websocket.send_text(message)
+    
+    async def get_data(self, websocket: WebSocket) -> dict:
+        return loads(await websocket.receive_text())
+
+    def acquire_cell_lock(
+            self, 
+            con_key: ConnectionKeyEnum, 
+            user_id: int,
+            cell_key: dict,
+            form_key: dict,
+    ) -> bool:
+        if not cell_key:
+            return False
+        cell_key = frozenset(cell_key.items())
+        
+        lock_key = (con_key, frozenset(form_key.items()), cell_key)
+        lock_owner_id = self.cell_locks.get(lock_key)
+        if lock_owner_id is not None and lock_owner_id != user_id:
+            return False
+        self.cell_locks[lock_key] = user_id
+        return True
+
+    def release_cell_lock(
+            self, 
+            con_key: ConnectionKeyEnum, 
+            user_id: int,
+            cell_key: dict,
+            form_key: dict,
+    ):
+        if not cell_key:
+            return
+        cell_key = frozenset(cell_key.items())
+
+        lock_key = (con_key, frozenset(form_key.items()), cell_key)
+        lock_owner_id = self.cell_locks.get(lock_key)
+        if lock_owner_id == user_id:
+            self.cell_locks.pop(lock_key, None)
+
+    def release_locks_for_user(
+            self, 
+            con_key: ConnectionKeyEnum, 
+            user_id: int,
+            form_key: dict
+        ):
+        filter_key = (con_key, frozenset(form_key.items()))
+        lock_keys = [
+            lock_key
+            for lock_key, lock_owner_id in self.cell_locks.items()
+            if lock_key[:-1] == filter_key and lock_owner_id == user_id
+        ]
+        for lock_key in lock_keys:
+            self.cell_locks.pop(lock_key, None)
+
+    def is_locked_by_other(
+            self, 
+            con_key: ConnectionKeyEnum, 
+            user_id: int,
+            cell_key: dict,
+            form_key,
+    ) -> bool:
+        if not cell_key:
+            return False
+        cell_key = frozenset(cell_key.items())
+        lock_owner_id = self.cell_locks.get((con_key, frozenset(form_key.items()), cell_key))
+        return lock_owner_id is not None and lock_owner_id != user_id
+
+    def is_row_locked_by_other(
+            self, 
+            con_key: ConnectionKeyEnum, 
+            user_id: int,
+            line_id: int,
+    ) -> bool:
+        if line_id is None:
+            return False
+
+        for (dict_con_key, form_key, cell_key), lock_owner_id in self.cell_locks.items():
+            if dict_con_key != con_key:
+                continue
+            
+            if form_key != form_key or lock_owner_id == user_id:
+                continue
+
+            for k, v in cell_key:
+                if k == "line_id" and v == line_id:
+                    return True
+        return False
+
+    def release_locks_for_row(
+            self, 
+            con_key: ConnectionKeyEnum, 
+            user_id: int,
+            line_id: int,
+    ) -> bool:
+        
+        if line_id is None:
+            return False
+        
+        lock_keys = []
+        for lock_key, lock_owner_id in self.cell_locks.items():
+            dict_con_key, form_key, cell_key = lock_key
+            if dict_con_key != con_key:
+                continue
+            
+            if form_key != form_key or lock_owner_id == user_id:
+                continue
+
+            for k, v in cell_key.items():
+                if k == "line_id" and v == line_id:
+                    lock_keys.append(lock_key)
+        
+        for lock_key in lock_keys:
+            self.cell_locks.pop(lock_key, None)
+
+
+class FormEventProcess:
+    def __init__(self, db: AsyncSession):
+        self.sheet_service: SheetService = SheetService(db)
+        self.bf_service: BudgetFormService = BudgetFormService(db)
+        self.bl_service: BudgetLineService = BudgetLineService(db)
+        self.user_service: UserService = UserService(db)
+
+
+    async def process(
+        self, 
+        event_data: dict, 
+        form_id: int, 
+        user_id: int,
+        sheet: str,
+        direction: str | None = None,
+    ) -> int | bool | dict:
+        curr_user: AppUser = await self.user_service.get(user_id)
+
+        match event_data["event"]:
+            case "cell_updated":
+                return await self.__update_cell(
+                    event_data=event_data["data"], 
+                    form_id=form_id, 
+                    user=curr_user,
+                    sheet=sheet,
+                    direction=direction,
+                )
+            case "row_added":
+                return await self.__add_row(
+                    event_data=event_data["data"], 
+                    form_id=form_id, 
+                    user=curr_user,
+                    sheet=sheet,
+                    direction=direction,
+                )
+            case "row_deleted":
+                return await self.__del_row(
+                    event_data=event_data["data"], 
+                    form_id=form_id, 
+                    user=curr_user,
+                    sheet=sheet,
+                    direction=direction,
+                )
+            case _:
+                pass
+
+    async def __update_cell(
+            self, 
+            event_data: dict, 
+            form_id: int, 
+            sheet: str, 
+            user: AppUser,
+            direction: str | None = None,
+    ) -> list[tuple]:
+        """
+        event_data: {
+            "line_id": int,
+            "column": str,
+            "value": any,
+        }
+        """
+        form = await self.bf_service.get(budget_form_id=form_id, user=user)
+        if not form:
+            return None
+
+        return await self.sheet_service.update_cell(
+            form_id=form_id, 
+            sheet=sheet,
+            direction=direction,
+            sections=None,
+            line_id=event_data["line_id"], 
+            column=event_data["column"], 
+            value=event_data["value"],
+            user=user,
+        )
+
+    async def __add_row(
+            self, 
+            event_data: dict, 
+            form_id: int, 
+            sheet: str,
+            user: AppUser,
+            direction: str | None,
+    ) -> list[tuple]:
+        """
+            data = {
+                expense_item_id: Optional[int] = None
+                item_id: Optional[str] = None
+                section_code: Optional[str] = None
+                name: Optional[str] = None
+                internal_order: Optional[str] = None
+                vsp_id: Optional[int] = None
+                project_id: Optional[int] = None
+                justification: Optional[str] = None
+                contract_number: Optional[str] = None
+                contract_end_date: Optional[datetime] = None
+            }
+        """
+        form = await self.bf_service.get(budget_form_id=form_id, user=user)
+        if not form:
+            return None
+
+        ids = await self.bl_service.get_ids(budget_form_id=form_id)
+        result = await self.sheet_service.add_line(
+            form_id=form_id,
+            sheet=sheet,
+            expense_item_id=event_data.get("expense_item_id"),
+            item_id=event_data.get("item_id"),
+            section_code=event_data.get("section_code"),
+            direction=direction,
+            name=event_data.get("name"),
+            internal_order=event_data.get("internal_order"),
+            vsp_id=event_data.get("vsp_id"),
+            project_id=event_data.get("project_id"),
+            justification=event_data.get("justification"),
+            contract_number=event_data.get("contract_number"),
+            contract_end_date=event_data.get("contract_end_date"),
+            user=user,
+        )
+        final_result = {
+            "data": result,
+            "new_line_id": None,
+        }
+        for el in result:
+            if el[3]["line_id"] and el[3]["line_id"] not in ids:
+                final_result["new_line_id"] = el[3]["line_id"]
+                return final_result
+        return final_result
+
+
+    async def __del_row(
+            self, 
+            event_data: dict, 
+            form_id: int, 
+            sheet: str,
+            user: AppUser,
+            direction: str | None,
+    ) -> list[tuple]:
+        """
+            data = {
+                "row_id": int,
+            }
+        """
+        form = await self.bf_service.get(budget_form_id=form_id, user=user)
+        if not form:
+            return None
+        result = await self.sheet_service.delete_line(
+            form_id=form_id,
+            sheet=sheet,
+            row_id=event_data["row_id"],
+            direction=direction,
+            user=user,
+        )
+        return result
+
+
+class ProjectEventProcess:
+    def __init__(self, db: AsyncSession):
+        self.project_service: ProjectService = ProjectService(db)
+        self.bf_service: BudgetFormService = BudgetFormService(db)
+        self.user_service: UserService = UserService(db)
+
+    async def process(
+        self, 
+        event_data: dict, 
+        project_id: int,
+        user_id: int,
+        year: int,
+        report_type: str,
+    ) -> int | bool | dict:
+        curr_user: AppUser = await self.user_service.get(user_id)
+
+        match event_data["event"]:
+            case "cell_updated":
+                return await self.__update_cell(
+                    event_data=event_data["data"],
+                    project_id=project_id,
+                    year=year,
+                    report_type=report_type,
+                    user=curr_user,
+                )
+            case "row_added":
+                return await self.__add_row(
+                    event_data=event_data["data"],
+                    project_id=project_id,
+                    year=year,
+                    report_type=report_type,
+                    user=curr_user,
+                )
+            case "row_deleted":
+                return await self.__del_row(
+                    event_data=event_data["data"],
+                    project_id=project_id,
+                    year=year,
+                    report_type=report_type,
+                    user=curr_user,
+                )
+            case _:
+                pass
+
+    async def __update_cell(
+            self, 
+            event_data: dict, 
+            project_id: int,
+            year: int,
+            report_type: str,
+            user: AppUser,
+    ) -> list[tuple]:
+        """
+        event_data: {
+            "line_id": int,
+            "column": str,
+            "value": any,
+        }
+        """
+        project = await self.project_service.get(project_id=project_id, user=user)
+        if not project:
+            return None
+
+        return await self.project_service.upd_form3_cell(
+            project_id=project_id,
+            year=year,
+            report_type=report_type,
+            line_id=event_data["line_id"],
+            column=event_data["column"],
+            value=event_data["value"],
+            user=user,
+        )
+
+    async def __add_row(
+            self, 
+            event_data: dict,
+            project_id: int,
+            year: int,
+            report_type: str,
+            user: AppUser,
+    ) -> list[tuple]:
+        """
+            data = {
+                expense_item_id: Optional[int] = None
+            }
+        """
+        project = await self.project_service.get(project_id=project_id, user=user)
+        if not project:
+            return None
+
+        return await self.project_service.add_form3_line(
+            project_id=project_id,
+            year=year,
+            report_type=report_type,
+            expense_item_id=event_data["expense_item_id"],
+            user=user,
+        )
+
+    async def __del_row(
+            self, 
+            event_data: dict, 
+            project_id: int,
+            year: int,
+            report_type: str,
+            user: AppUser,
+    ) -> list[tuple]:
+        """
+            data = {
+                "line_id": int,
+            }
+        """
+        project = await self.project_service.get(project_id=project_id, user=user)
+        if not project:
+            return None
+
+        return await self.project_service.del_form3_line(
+            project_id=project_id,
+            year=year,
+            report_type=report_type,
+            line_id=event_data["line_id"],
+            user=user,
+        )
+
+
+manager = ConnectionManager()
+
+
+def _convert_error(o):
+    try:
+        return asdict(o)
+    except TypeError:
+        return o
+
+
+async def login(websocket: WebSocket, **kwargs) -> int:
+    user_data = await manager.get_data(websocket=websocket)
+    if user_data.get("event") != "user_login":
+        return None
+
+    async with get_db_session() as db:
+        user = await get_user_by_token(token=user_data["data"].get("token"), db=db)
+        if not user:
+            return None
+        manager.set_user(
+            websocket=websocket, 
+            user_id=user.id, 
+            **kwargs,
+        )
+        return user.id
+
+
+
+
+def resolve_cell_key(event_data: dict) -> dict | None:
+    data = event_data.get("data")
+
+    if not data or "line_id" not in data or "column" not in data:
+        return None
+    return {
+        "line_id": data["line_id"],
+        "column": data["column"],
+    }
+
+
+async def process_websocket(
+    websocket: WebSocket,
+    processor_cls,
+    **kwargs,
+):
+    await manager.connect(
+        websocket=websocket, 
+        **kwargs,
+    )
+
+    
+    kwargs_process = kwargs.copy()
+    if "con_key" in kwargs_process:
+        kwargs_process.pop("con_key")
+    con_key = kwargs.get("con_key")
+
+    try:
+        user_id = await login(
+            websocket=websocket,
+            **kwargs,
+        )
+        if user_id is None:
+            
+            await manager.disconnect(
+                websocket=websocket,
+                reason="Ошибка авторизации",
+                **kwargs,
+            )
+            return
+    
+        while True:
+            data = loads(await websocket.receive_text())
+
+            try:
+                event_name = data.get("event")
+                cell_key = resolve_cell_key(data)
+
+                match event_name:
+                    case "cell_edit_start":
+                        if not manager.acquire_cell_lock(
+                            con_key=con_key,
+                            user_id=user_id,
+                            cell_key=cell_key,
+                            form_key=kwargs_process,
+                        ):
+                            data["error"] = "Ячейка уже редактируется другим пользователем"
+                            await manager.send_back(
+                                dumps(data, default=_convert_error, ensure_ascii=False), 
+                                websocket,
+                            )
+                            continue
+                        await manager.send_back(
+                            dumps(data, default=_convert_error, ensure_ascii=False), 
+                            websocket,
+                        )
+                        await manager.broadcast_to_other(
+                            message=dumps(data, default=_convert_error, ensure_ascii=False),
+                            user_id=user_id,
+                            con_key=con_key,
+                            **kwargs_process,
+                        )
+                        continue
+                    case "cell_edit_end":
+                        manager.release_cell_lock(
+                            con_key=con_key,
+                            user_id=user_id,
+                            cell_key=cell_key,
+                            form_key=kwargs_process,
+                        )
+                        await manager.send_back(
+                            dumps(data, default=_convert_error, ensure_ascii=False), 
+                            websocket,
+                        )
+                        await manager.broadcast_to_other(
+                            message=dumps(data, default=_convert_error, ensure_ascii=False),
+                            user_id=user_id,
+                            con_key=con_key,
+                            **kwargs_process,
+                        )
+                        continue
+                    case "cell_updated":
+                        if manager.is_locked_by_other(
+                                con_key=con_key,
+                                user_id=user_id,
+                                cell_key=cell_key,
+                                form_key=kwargs_process,
+                        ):
+                            data["error"] = "Ячейка уже редактируется другим пользователем"
+                            await manager.send_back(
+                                dumps(data, default=_convert_error, ensure_ascii=False), 
+                                websocket,
+                            )
+                            continue
+                        if cell_key and not manager.acquire_cell_lock(
+                            con_key=con_key,
+                            user_id=user_id,
+                            cell_key=cell_key,
+                            form_key=kwargs_process,
+                        ):
+                            data["error"] = "Ячейка уже редактируется другим пользователем"
+                            await manager.send_back(
+                                dumps(data, default=_convert_error, ensure_ascii=False), 
+                                websocket,
+                            )
+                            continue
+                    case "row_deleted":
+                        if manager.is_row_locked_by_other(
+                            con_key=con_key,
+                            user_id=user_id,
+                            line_id=data["data"]["row_id"]
+                        ):
+                            data["error"] = (
+                                "Нельзя удалить строку: в этой строке есть редактируемые ячейки"
+                            )
+                            await manager.send_back(
+                                dumps(data, default=_convert_error, ensure_ascii=False), 
+                                websocket,
+                            )
+                            continue
+                    case _:
+                        pass
+
+                async with get_db_session() as db:
+                    processor = processor_cls(db)
+                    data["result"] = await processor.process(
+                        event_data=data, 
+                        user_id=user_id,
+                        **kwargs_process
+                    )
+                    await db.commit()
+                
+                if data.get("event") == "row_deleted":
+                    manager.release_locks_for_row(
+                        con_key=con_key,
+                        user_id=user_id,
+                        line_id=data["data"]["row_id"]
+                    )
+                
+                if data.get("event") in [
+                    "cell_updated",
+                    "row_added",
+                    "row_deleted",
+                ]:
+                    await manager.broadcast_to_all(
+                        message=dumps(data, default=_convert_error),
+                        **kwargs
+                    )
+                else:
+                    await manager.broadcast_to_other(
+                        message=dumps(data, default=_convert_error),
+                        user_id=user_id,
+                        **kwargs,
+                    )
+
+            except BasicAppException as e:
+                data["error"] = e.description or "Неизвестная ошибка"
+                await manager.send_back(
+                    message=dumps(data, default=_convert_error), 
+                    websocket=websocket,
+                )
+            except IntegrityError as e:
+                data["error"] = str(e)
+                await manager.send_back(
+                    message=dumps(data, default=_convert_error), 
+                    websocket=websocket,
+                )
+
+            except Exception as e:
+                tp = type(e)
+                handlers = websocket.app.exception_handlers
+                if tp in handlers:
+                    data["error"] = loads((await handlers[tp](request=None, exc=e)).body)
+                    await manager.send_back(
+                        message=dumps(data, default=_convert_error), 
+                        websocket=websocket,
+                    )
+                else:
+                    raise e
+
+    except WebSocketDisconnect:
+        await manager.disconnect(
+            websocket=websocket,
+            **kwargs
+        )
+
+    except Exception as e:
+        # Логируем ошибку, но не бросаем HTTPException — это WebSocket
+        print(f"Error: {e}")
+        await manager.disconnect(
+            websocket=websocket,
+            **kwargs,
+        )
+
+
+@router.websocket("/form/{form_id}/sheet/{sheet}")
+async def websocket_form(
+    websocket: WebSocket,
+    form_id: int,
+    sheet: str,
+    direction: Optional[str] = None,
+):
+    await process_websocket(
+        websocket=websocket,
+        form_id=form_id,
+        sheet=sheet,
+        direction=direction,
+        processor_cls=FormEventProcess,
+        con_key=ConnectionKeyEnum.FORM,
+    )
+
+
+@router.websocket("/projects/{project_id}/report/{year}/{report_type}")
+async def websocket_project(
+    websocket: WebSocket,
+    project_id: int,
+    year: int,
+    report_type: str,
+):
+    await process_websocket(
+        websocket=websocket,
+        project_id=project_id,
+        year=year,
+        report_type=report_type,
+        processor_cls=ProjectEventProcess,
+        con_key=ConnectionKeyEnum.PROJECT,
+    )

api/src/core/CONSTANTS.py

@@ -0,0 +1,31 @@
+VALIDATION_PREFIXES = (
+    "computed_field:",
+    "normative_field:",
+    "unknown_column:",
+    "key_field:",
+    "structural_field:",
+    "bad_column_format:",
+    "bad_booking_year:",
+    "bad_booking_quarter:",
+    "unsupported_scope:",
+)
+
+PG_404_ERRORS = (
+    "не существует",
+    "не принадлежит",
+    "not found",
+)
+PG_409_ERRORS = (
+    "unique",
+    "duplicate",
+    "foreign key",
+)
+PG_400_ERRORS = (
+    "violates check constraint",
+)
+PG_403_ERRORS = (
+    "permission denied",
+    "insufficient privilege",
+    "role_not_allowed:",
+    "window_closed:",
+)

api/src/core/config.py

@@ -105,6 +105,11 @@ class Settings(BaseSettings):
         description="Размер батча для очистки аудита",
         alias="AUDIT_LOG_CLEANUP_BATCH_SIZE",
     )
+    AUDIT_LOG_CLEANUP_INTERVAL_SECONDS: int = Field(
+        default=86400,
+        description="Интервал автозапуска очистки аудита в секундах",
+        alias="AUDIT_LOG_CLEANUP_INTERVAL_SECONDS",
+    )
 
     model_config = SettingsConfigDict(
         env_file=".env",

api/src/core/errors.py

@@ -1,6 +1,8 @@
 from pydantic import BaseModel, Field
 
 
+
+
 class ValidationError(BaseModel):
     field: str = Field(...)
     description: str = Field(...)
@@ -10,6 +12,14 @@ class BasicAppException(Exception):
     description: str | None = None
 
 
+class ValidationsError(BasicAppException):
+    errors: dict[str, list[str]]
+
+    def __init__(self, errors, *args):
+        super().__init__(*args)
+        self.errors = errors
+
+
 class AccessDeniedException(BasicAppException):
     description = "Доступ запрещен"
 

api/src/core/exception_handlers.py

@@ -1,5 +1,6 @@
-from fastapi import FastAPI, status
+from fastapi import FastAPI, HTTPException, status
 from fastapi.responses import JSONResponse
+from sqlalchemy.exc import IntegrityError, OperationalError, SQLAlchemyError, DBAPIError
 
 from src.core.errors import (
     AccessDeniedException,
@@ -7,41 +8,145 @@ from src.core.errors import (
     UserNotFoundException,
     UsernameConflictException,
     ValidationException,
+    ValidationsError,
 )
+from src.core.CONSTANTS import (
+    VALIDATION_PREFIXES,
+    PG_404_ERRORS,
+    PG_409_ERRORS,
+    PG_400_ERRORS,
+    PG_403_ERRORS,
+)
+
+def _error_payload(code: str | int, message: str, field: str | None = None) -> dict:
+    """Формирует структурированный payload ошибки по спеке."""
+    return {
+        "code": code,
+        "field": field,
+        "message": message,
+    }
+
+
+def _parse_prefixed_validation_error(message: str) -> tuple[str, str | None]:
+    for prefix in VALIDATION_PREFIXES:
+        if message.lower().startswith(prefix):
+            code = prefix[:-1]
+            field = message.split(":", 1)[1].strip() if ":" in message else None
+            return code, field or None
+    return "validation_error", None
+
+
+def _first_db_message_line(message: str) -> str:
+    """Возвращает первую непустую строку текста ошибки БД."""
+    for line in message.splitlines():
+        line = line.strip()
+        if line:
+            return line
+    return message.strip()
+
+
+def map_sqlalchemy_error(exc: SQLAlchemyError) -> tuple[int, str, str, str | None]:
+    """Маппинг ошибок SQLAlchemy в HTTP-статус + code/message/field."""
+    raw = str(getattr(exc, "orig", exc) or exc).strip()
+    message = _first_db_message_line(raw) or "Database error"
+    low = message.lower()
+
+    if any(low.startswith(prefix) for prefix in VALIDATION_PREFIXES):
+        code, field = _parse_prefixed_validation_error(message)
+        return status.HTTP_422_UNPROCESSABLE_ENTITY, code, message, field
+    if any(error in low for error in PG_404_ERRORS):
+        return status.HTTP_404_NOT_FOUND, "not_found", message, None
+    if any(error in low for error in PG_403_ERRORS):
+        return status.HTTP_403_FORBIDDEN, "access_denied", message, None
+
+    if isinstance(exc, IntegrityError):
+        if any(error in low for error in PG_409_ERRORS):
+            return status.HTTP_409_CONFLICT, "conflict", message, None
+        if any(error in low for error in PG_400_ERRORS):
+            return status.HTTP_400_BAD_REQUEST, "db_error", message, None
+        return status.HTTP_400_BAD_REQUEST, "db_error", message, None
+
+    if isinstance(exc, OperationalError):
+        return status.HTTP_503_SERVICE_UNAVAILABLE, "db_unavailable", "Database unavailable", None
+
+    return status.HTTP_400_BAD_REQUEST, "db_error", message, None
+
+
+def map_http_exception(exc: HTTPException) -> tuple[int, str | int, str, str | None]:
+    """Маппинг HTTPException в единый формат ошибки API."""
+    status_code = int(exc.status_code)
+    detail = exc.detail
+
+    if isinstance(detail, dict):
+        message = str(detail.get("message") or detail.get("detail") or "HTTP error")
+        field = detail.get("field")
+        if field is not None:
+            field = str(field)
+        code = detail.get("code", status_code)
+        return status_code, code, message, field
+
+    message = str(detail) if detail else "HTTP error"
+    return status_code, status_code, message, None
 
 
 def register_exception_handlers(app: FastAPI) -> None:
+    @app.exception_handler(HTTPException)
+    async def http_exception_handler(request, exc: HTTPException):
+        status_code, code, message, field = map_http_exception(exc)
+        return JSONResponse(
+            status_code=status_code,
+            content=_error_payload(code, message, field=field),
+            headers=exc.headers,
+        )
+
     @app.exception_handler(AccessDeniedException)
     async def access_denied_exception_handler(request, exc: AccessDeniedException):
         return JSONResponse(
             status_code=status.HTTP_403_FORBIDDEN,
-            content={"detail": exc.description},
+            content=_error_payload("access_denied", exc.description),
         )
 
     @app.exception_handler(ValidationException)
     async def validation_exception_handler(request, exc: ValidationException):
         return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
-            content={"detail": exc.description},
+            content=_error_payload("validation_error", exc.description, field=exc.field),
         )
 
     @app.exception_handler(UserNotFoundException)
     async def user_not_found_exception_handler(request, exc: UserNotFoundException):
         return JSONResponse(
             status_code=status.HTTP_404_NOT_FOUND,
-            content={"detail": exc.description},
+            content=_error_payload("user_not_found", exc.description),
         )
 
     @app.exception_handler(UsernameConflictException)
     async def username_conflict_exception_handler(request, exc: UsernameConflictException):
         return JSONResponse(
             status_code=status.HTTP_409_CONFLICT,
-            content={"detail": exc.description},
+            content=_error_payload("username_conflict", exc.description),
         )
 
     @app.exception_handler(BasicAppException)
     async def basic_app_exception_handler(request, exc: BasicAppException):
+        message = exc.description or "Application error"
         return JSONResponse(
             status_code=status.HTTP_400_BAD_REQUEST,
-            content={"detail": exc.description or "Application error"},
+            content=_error_payload("application_error", message),
+        )
+
+    @app.exception_handler(SQLAlchemyError)
+    @app.exception_handler(DBAPIError)
+    async def sqlalchemy_exception_handler(request, exc: SQLAlchemyError):
+        status_code, code, message, field = map_sqlalchemy_error(exc)
+        return JSONResponse(
+            status_code=status_code,
+            content=_error_payload(code, message, field=field),
+        )
+
+    @app.exception_handler(ValidationsError)
+    async def validations_error_handler(request, exc: ValidationsError):
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=exc.errors,
         )

api/src/db/base.py

@@ -7,12 +7,15 @@ connect_args = {}
 if settings.DATABASE_SCHEMA:
     connect_args["server_settings"] = {"search_path": settings.DATABASE_SCHEMA}
 
+
 if "sqlite" in settings.DATABASE_URL:
     connect_args["check_same_thread"] = False
 
 engine = create_async_engine(
     settings.DATABASE_URL,
     pool_pre_ping=True,
+    pool_size=5,
+    max_overflow=10,
     connect_args=connect_args,
 )
 

api/src/db/models/__init__.py

@@ -0,0 +1,30 @@
+from src.db.models.allocation import Allocation
+from src.db.models.app_user import AppUser
+from src.db.models.audit_log import AuditLog
+from src.db.models.booking import Booking
+from src.db.models.budget_form import BudgetForm
+from src.db.models.budget_line import BudgetLine
+from src.db.models.budget_line_quarter import BudgetLineQuarter
+from src.db.models.ckk import Ckk
+from src.db.models.collegial_approval import CollegialApproval
+from src.db.models.contract_detail import ContractDetail
+from src.db.models.contract_summary import ContractSummary
+from src.db.models.form_limit import FormLimit
+from src.db.models.form_phase import FormPhase
+from src.db.models.form_type import FormType
+from src.db.models.limit_template import LimitTemplate
+from src.db.models.org_unit import OrgUnit
+from src.db.models.phase_template import PhaseTemplate
+from src.db.models.plan import Plan
+from src.db.models.project import Project
+from src.db.models.rent_detail import RentDetail
+from src.db.models.reserve import Reserve
+from src.db.models.rf_project_report import RfProjectReport
+from src.db.models.rf_project_report_line import RfProjectReportLine
+from src.db.models.rf_project_report_quarter import RfProjectReportQuarter
+from src.db.models.role import Role
+from src.db.models.security_detail import SecurityDetail
+from src.db.models.sequestration import Sequestration
+from src.db.models.user_org import UserOrg
+from src.db.models.utility_detail import UtilityDetail
+from src.db.models.vsp import Vsp

api/src/db/models/allocation.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Allocation(Base):
+    __tablename__ = "allocation"
+    __table_args__ = {"schema": "v3"}
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    internal_order: Mapped[str | None] = mapped_column(String)
+    property_object: Mapped[str | None] = mapped_column(String)
+    contract_ref: Mapped[str | None] = mapped_column(String)
+    allocation_purpose: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine", uselist=False)

api/src/db/models/app_user.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import Boolean, DateTime, ForeignKey, Index, String, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class AppUser(Base):
+    __tablename__ = "app_user"
+    __table_args__ = (
+        Index(
+            "ix_v4_app_user_active",
+            "is_active",
+            postgresql_where="is_active",
+        ),
+        Index("ix_v4_app_user_role", "role_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    email: Mapped[str] = mapped_column(String)
+    username: Mapped[str] = mapped_column(String)
+    hashed_password: Mapped[str] = mapped_column(String)
+    full_name: Mapped[str | None] = mapped_column(String)
+    role_id: Mapped[int] = mapped_column(ForeignKey("v3.role.id"))
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+
+#     role: Mapped["Role"] = relationship("Role", back_populates="users")  # type: ignore
+#     created_budget_forms: Mapped[list["BudgetForm"]] = relationship(  # type: ignore
+#         "BudgetForm", back_populates="creator", foreign_keys="BudgetForm.created_by"
+#     )
+#     updated_budget_forms: Mapped[list["BudgetForm"]] = relationship(  # type: ignore
+#         "BudgetForm", back_populates="updater", foreign_keys="BudgetForm.updated_by"
+#     )
+#     created_rf_reports: Mapped[list["RfProjectReport"]] = relationship(  # type: ignore
+#         "RfProjectReport",
+#         back_populates="creator",
+#         foreign_keys="RfProjectReport.created_by",
+#     )
+#     updated_rf_reports: Mapped[list["RfProjectReport"]] = relationship(  # type: ignore
+#         "RfProjectReport",
+#         back_populates="updater",
+#         foreign_keys="RfProjectReport.updated_by",
+#     )
+    audit_logs: Mapped[list["AuditLog"]] = relationship(  # type: ignore
+        "AuditLog", back_populates="user"
+    )
+    user_orgs: Mapped[list["UserOrg"]] = relationship("UserOrg", back_populates="user")
+    org_units: Mapped[list["OrgUnit"]] = relationship("OrgUnit", secondary="v3.user_org", viewonly=True)

api/src/db/models/audit_log.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import (
+    BigInteger,
+    DateTime,
+    ForeignKey,
+    Index,
+    JSON,
+    String,
+    func,
+    text,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class AuditLog(Base):
+    __tablename__ = "audit_log"
+    __table_args__ = (
+        Index("ix_v3_audit_log_dt", text("event_dt DESC")),
+        Index("ix_v3_audit_log_event", "event"),
+        Index(
+            "ix_v3_audit_log_form",
+            "form_id",
+            postgresql_where="form_id IS NOT NULL",
+        ),
+        Index("ix_v3_audit_log_user", "user_id"),
+        Index("ix_v4_audit_log_dt", text("event_dt DESC")),
+        Index("ix_v4_audit_log_event", "event"),
+        Index(
+            "ix_v4_audit_log_form",
+            "form_id",
+            postgresql_where="form_id IS NOT NULL",
+        ),
+        Index("ix_v4_audit_log_user", "user_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
+    user_id: Mapped[int | None] = mapped_column(
+        ForeignKey("v3.app_user.id", ondelete="SET NULL")
+    )
+    org_unit_id: Mapped[int | None] = mapped_column(
+        ForeignKey("v3.org_unit.id", ondelete="SET NULL")
+    )
+    task_id: Mapped[int | None] = mapped_column()
+    form_id: Mapped[int | None] = mapped_column()
+    event_dt: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+    event: Mapped[str] = mapped_column(String)
+    event_type: Mapped[str] = mapped_column(String)
+    event_data: Mapped[dict | None] = mapped_column(JSON)
+
+    user: Mapped["AppUser | None"] = relationship(
+        "AppUser", back_populates="audit_logs"
+    )
+#     org_unit: Mapped["OrgUnit | None"] = relationship(
+#         "OrgUnit", back_populates="audit_logs"
+#     )

api/src/db/models/booking.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, ForeignKey, Index, Integer, Numeric, SmallInteger, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Booking(Base):
+    __tablename__ = "booking"
+    __table_args__ = (
+        CheckConstraint("quarter BETWEEN 1 AND 4", name="ck_v3_booking_quarter"),
+        CheckConstraint("source IN ('CKK','CONTRACT')", name="ck_v3_booking_source"),
+        Index("ix_v3_booking_line", "line_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"))
+    quarter: Mapped[int] = mapped_column(SmallInteger)
+    source: Mapped[str] = mapped_column(String)
+    booked_amount_ckk: Mapped[float | None] = mapped_column(Numeric)
+    booked_amount_contract: Mapped[float | None] = mapped_column(Numeric)
+
+#     line = relationship("BudgetLine")

api/src/db/models/budget_form.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+import typing
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.models.form_type import FormTypeEnum
+from src.db.base import Base
+
+
+class BudgetForm(Base):
+    __tablename__ = "budget_form"
+    __table_args__ = {"schema": "v3"}
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    form_type_code: Mapped[FormTypeEnum] = mapped_column( #type: ignore
+        String, ForeignKey("v3.form_type.code")
+    )
+    year: Mapped[int | None] = mapped_column(Integer)
+    created_by: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("v3.app_user.id", name="fk_v3_budget_form_created_by")
+    )
+    created_at: Mapped[datetime | None] = mapped_column(
+        DateTime, server_default=func.now()
+    )
+    updated_by: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("v3.app_user.id", name="fk_v3_budget_form_updated_by")
+    )
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime)
+    org_unit_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("v3.org_unit.id", name="fk_v3_budget_form_org_unit")
+    )
+
+    form_type: Mapped["FormType"] = relationship(
+        "FormType", #back_populates="budget_forms"
+    )
+#     creator: Mapped[typing.Optional["AppUser"]] = relationship(
+#         "AppUser", back_populates="created_budget_forms", foreign_keys=[created_by]
+#     )
+#     updater: Mapped[typing.Optional["AppUser"]] = relationship(
+#         "AppUser", back_populates="updated_budget_forms", foreign_keys=[updated_by]
+#     )
+    org_unit: Mapped[typing.Optional["OrgUnit"]] = relationship(
+        "OrgUnit", #back_populates="budget_forms"
+    )
+#     budget_lines: Mapped[list["BudgetLine"]] = relationship(
+#         "BudgetLine", back_populates="budget_form"
+#     )
+#     fixed_asset_reports: Mapped[list["FixedAssetReport"]] = relationship(
+#         "FixedAssetReport", back_populates="budget_form"
+#     )
+#     form_phases: Mapped[list["FormPhase"]] = relationship(
+#         "FormPhase", back_populates="budget_form"
+#     )
+#     form_limits: Mapped[list["FormLimit"]] = relationship(
+#         "FormLimit", back_populates="budget_form"
+#     )

api/src/db/models/budget_line.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, ForeignKey, Index, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class BudgetLine(Base):
+    __tablename__ = "budget_line"
+    __table_args__ = (
+        Index("ix_v3_budget_line_form_item", "budget_form_id", "expense_item_id"),
+        Index("ix_v3_budget_line_vsp", "vsp_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    budget_form_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_form.id"))
+    expense_item_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.expense_item.id"))
+    name: Mapped[str | None] = mapped_column(String)
+    internal_order: Mapped[str | None] = mapped_column(String)
+    vsp_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.vsp.id"))
+    project_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.project.id"))
+    justification: Mapped[str | None] = mapped_column(String)
+    created_by: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.app_user.id"))
+    created_at: Mapped[datetime | None] = mapped_column(DateTime, default=None)
+    updated_by: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.app_user.id"))
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime, default=None)
+    direction: Mapped[str | None] = mapped_column(String)
+
+#     budget_form = relationship("BudgetForm", back_populates="budget_lines")
+#     expense_item = relationship("ExpenseItem", back_populates="budget_lines")
+#     vsp = relationship("Vsp", back_populates="budget_lines")
+#     project = relationship("Project", back_populates="budget_lines")
+
+#     ckk = relationship("Ckk", uselist=False)
+#     collegial_approval = relationship("CollegialApproval", uselist=False)
+#     contract_detail = relationship("ContractDetail", uselist=False)
+#     contract_summary = relationship("ContractSummary", uselist=False)
+#     plan = relationship("Plan", uselist=False)
+#     reserve = relationship("Reserve", uselist=False)
+#     allocation = relationship("Allocation", uselist=False)
+
+#     quarters: Mapped[list["BudgetLineQuarter"]] = relationship("BudgetLineQuarter", back_populates="line")  # type: ignore
+#     sequestration_records: Mapped[list["Sequestration"]] = relationship("Sequestration", back_populates="budget_line")  # type: ignore
+#     booking_records: Mapped[list["Booking"]] = relationship("Booking", back_populates="budget_line")  # type: ignore
+#     rent_details: Mapped[list["RentDetail"]] = relationship("RentDetail", back_populates="budget_line")  # type: ignore
+#     security_details: Mapped[list["SecurityDetail"]] = relationship("SecurityDetail", back_populates="budget_line")  # type: ignore
+#     utility_details: Mapped[list["UtilityDetail"]] = relationship("UtilityDetail", back_populates="budget_line")  # type: ignore

api/src/db/models/budget_line_quarter.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from datetime import date
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, SmallInteger, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class BudgetLineQuarter(Base):
+    __tablename__ = "budget_line_quarter"
+    __table_args__ = (
+        CheckConstraint("quarter >= 1 AND quarter <= 4", name="chk_budget_line_quarter_quarter"),
+        {"schema": "v3"},
+    )
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    quarter: Mapped[int] = mapped_column(SmallInteger, primary_key=True)
+    adj_current: Mapped[float | None] = mapped_column(Numeric)
+    adj_ssp: Mapped[float | None] = mapped_column(Numeric)
+    adj_rf: Mapped[float | None] = mapped_column(Numeric)
+    adj_reserve: Mapped[float | None] = mapped_column(Numeric)
+    adj_comment: Mapped[str | None] = mapped_column(String)
+    target_change: Mapped[float | None] = mapped_column(Numeric)
+    base_plan_correction: Mapped[float | None] = mapped_column(Numeric)
+    base_plan_correction_comment: Mapped[str | None] = mapped_column(String)
+    payment_date: Mapped[date | None] = mapped_column(Date)
+    payment_amount: Mapped[float | None] = mapped_column(Numeric)
+    payment_amount_ho: Mapped[float | None] = mapped_column(Numeric)
+    payment_amount_rf: Mapped[float | None] = mapped_column(Numeric)
+    payment_comment: Mapped[str | None] = mapped_column(String)
+    payment_act: Mapped[str | None] = mapped_column(String)
+    actual_m1: Mapped[float | None] = mapped_column(Numeric)
+    actual_m2: Mapped[float | None] = mapped_column(Numeric)
+    actual_m3: Mapped[float | None] = mapped_column(Numeric)
+    actual_spod: Mapped[float | None] = mapped_column(Numeric)
+    transfer_to_q2: Mapped[float | None] = mapped_column(Numeric)
+    transfer_to_q3: Mapped[float | None] = mapped_column(Numeric)
+    transfer_to_q4: Mapped[float | None] = mapped_column(Numeric)
+    transfer_to_economy: Mapped[float | None] = mapped_column(Numeric)
+    transfer_delay_acts: Mapped[float | None] = mapped_column(Numeric)
+    transfer_delay_procurement: Mapped[float | None] = mapped_column(Numeric)
+    transfer_economy_rf: Mapped[float | None] = mapped_column(Numeric)
+    transfer_next_comment: Mapped[str | None] = mapped_column(String)
+    transfer_far_comment: Mapped[str | None] = mapped_column(String)
+    booking_amount: Mapped[float | None] = mapped_column(Numeric)
+    plan_revision_eco_change: Mapped[float | None] = mapped_column(Numeric)
+    plan_revision_item_adj: Mapped[float | None] = mapped_column(Numeric)
+    plan_revision_increase: Mapped[float | None] = mapped_column(Numeric)
+    plan_revision_sequester: Mapped[float | None] = mapped_column(Numeric)
+    plan_revision_comment: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine", back_populates="quarters")

api/src/db/models/ckk.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Ckk(Base):
+    __tablename__ = "ckk"
+    __table_args__ = {"schema": "v3"}
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    ceiling_amount: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q1: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q2: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q3: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q4: Mapped[float | None] = mapped_column(Numeric)
+    expenses_next_year_q1: Mapped[float | None] = mapped_column(Numeric)
+    expenses_next_year_q2: Mapped[float | None] = mapped_column(Numeric)
+    expenses_next_year_q3: Mapped[float | None] = mapped_column(Numeric)
+    expenses_next_year_q4: Mapped[float | None] = mapped_column(Numeric)
+    rf_schedule: Mapped[str | None] = mapped_column(String)
+    delivery_deadline: Mapped[str | None] = mapped_column(String)
+    procurement_plan: Mapped[str | None] = mapped_column(String)
+    procurement_method: Mapped[str | None] = mapped_column(String)
+    comment: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine", uselist=False)

api/src/db/models/collegial_approval.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class CollegialApproval(Base):
+    __tablename__ = "collegial_approval"
+    __table_args__ = {"schema": "v3"}
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    approved_amount: Mapped[float | None] = mapped_column(Numeric)
+    protocol_reference: Mapped[str | None] = mapped_column(String)
+    note: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine", uselist=False)

api/src/db/models/contract_detail.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class ContractDetail(Base):
+    __tablename__ = "contract_detail"
+    __table_args__ = {"schema": "v3"}
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    counterparty: Mapped[str | None] = mapped_column(String)
+    reference: Mapped[str | None] = mapped_column(String)
+    addenda: Mapped[str | None] = mapped_column(String)
+    subject: Mapped[str | None] = mapped_column(String)
+    currency: Mapped[str | None] = mapped_column(String)
+    ceiling_amount: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q1: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q2: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q3: Mapped[float | None] = mapped_column(Numeric)
+    expenses_q4: Mapped[float | None] = mapped_column(Numeric)
+    rf_schedule: Mapped[str | None] = mapped_column(String)
+    vat_rate: Mapped[str | None] = mapped_column(String)
+    exchange_rate: Mapped[float | None] = mapped_column(Numeric)
+    amount_foreign: Mapped[float | None] = mapped_column(Numeric)
+    deadline: Mapped[str | None] = mapped_column(String)
+    payment_scheme: Mapped[str | None] = mapped_column(String)
+    act: Mapped[str | None] = mapped_column(String)
+    comment: Mapped[str | None] = mapped_column(String)
+    contract_date: Mapped[str | None] = mapped_column(Date)
+
+#     line = relationship("BudgetLine", uselist=False)

api/src/db/models/contract_summary.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class ContractSummary(Base):
+    __tablename__ = "contract_summary"
+    __table_args__ = {"schema": "v3"}
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    total_amount: Mapped[float | None] = mapped_column(Numeric)
+    counterparty: Mapped[str | None] = mapped_column(String)
+    reference: Mapped[str | None] = mapped_column(String)
+    deadline: Mapped[str | None] = mapped_column(String)
+    comment: Mapped[str | None] = mapped_column(String)
+    future_payments_y1: Mapped[float | None] = mapped_column(Numeric)
+    future_payments_y2: Mapped[float | None] = mapped_column(Numeric)
+    other_ssp_amount: Mapped[float | None] = mapped_column(Numeric)
+    centralized_flag: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine", uselist=False)

api/src/db/models/form_limit.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from sqlalchemy import ForeignKey, Index, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class FormLimit(Base):
+    __tablename__ = "form_limit"
+    __table_args__ = (
+        Index("ix_v3_form_limit_form", "budget_form_id"),
+        {"schema": "v3"},
+    )
+
+    budget_form_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_form.id", ondelete="CASCADE"), primary_key=True)
+    template_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.limit_template.id", ondelete="CASCADE"), primary_key=True)
+    qty_q1: Mapped[int | None] = mapped_column(Integer)
+    qty_q2: Mapped[int | None] = mapped_column(Integer)
+    qty_q3: Mapped[int | None] = mapped_column(Integer)
+    qty_q4: Mapped[int | None] = mapped_column(Integer)
+    comment: Mapped[str | None] = mapped_column(String)
+
+#     budget_form = relationship("BudgetForm")
+#     template = relationship("LimitTemplate")

api/src/db/models/form_phase.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+from sqlalchemy import ARRAY, CheckConstraint, DateTime, ForeignKey, String, Text, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from src.db.base import Base
+
+
+class FormPhase(Base):
+    __tablename__ = "form_phase"
+    __table_args__ = (
+        CheckConstraint(text("cardinality(column_keys) > 0"), name="chk_v4_form_phase_columns"),
+        CheckConstraint(text("role != 'ADMIN'"), name="chk_v4_form_phase_no_admin"),
+        CheckConstraint(text("closes_at > opens_at"), name="chk_v4_form_phase_window"),
+        {"schema": "v3"},
+    )
+
+    budget_form_id: Mapped[int] = mapped_column(
+        ForeignKey("v3.budget_form.id", ondelete="CASCADE"), primary_key=True
+    )
+    sheet: Mapped[str] = mapped_column(String, primary_key=True)
+    phase_code: Mapped[str] = mapped_column(String, primary_key=True)
+    role: Mapped[str] = mapped_column(String, ForeignKey("v3.role.code"))
+    column_keys: Mapped[list[str]] = mapped_column(ARRAY(Text))
+    opens_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+    closes_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))

api/src/db/models/form_type.py

@@ -0,0 +1,79 @@
+import enum
+
+from sqlalchemy import CheckConstraint, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class FormTypeEnum(str, enum.Enum):
+    FORM_1 = "FORM_1"
+    FORM_2 = "FORM_2"
+    FORM_3 = "FORM_3"
+    FORM_4 = "FORM_4"
+
+
+class FormType(Base):
+    __tablename__ = "form_type"
+    __table_args__ = (
+        CheckConstraint("scope IN ('GO','PD','RF')", name="ck_form_type_scope"),
+        CheckConstraint(
+            "storage_entity IN ('BUDGET_FORM','RF_PROJECT_REPORT')",
+            name="ck_form_type_storage_entity",
+        ),
+        {"schema": "v3"},
+    )
+
+    code: Mapped[str] = mapped_column(String, primary_key=True)
+    name: Mapped[str | None] = mapped_column(String)
+    scope: Mapped[str | None] = mapped_column(String)
+    storage_entity: Mapped[str | None] = mapped_column(String)
+
+    
+    SHEETS_BY_FORM_TYPE = {
+        FormTypeEnum.FORM_1: ["AHR", "CAP", "OPER", "SMETA"],
+        FormTypeEnum.FORM_2: ["AHR", "CAP", "OPER", "AHR_LIMIT", "AHR_RENT",
+                "AHR_UTILITY", "AHR_SECURITY", "OTCH9F", "SMETA"],
+        FormTypeEnum.FORM_3: ["LIMIT", "CURRENT_EXPENSES"],
+        FormTypeEnum.FORM_4: ["AHR", "CAP", "OPER", "STRUCTURE", "SMETA"],
+    }
+    SECTIONS_BY_FORM_TYPE = {
+        FormTypeEnum.FORM_1: ["plan", "contract_summary", "allocation", "sequestration", "reserve", "approved", "collegial", "ckk", "contract_detail", "q1", "q2", "q3", "q4", "totals"],
+        FormTypeEnum.FORM_2: ["plan", "seq_dfip", "seq_ssp", "approved", "contract", "booking", "q1", "q2", "q3", "q4", "totals"],
+        FormTypeEnum.FORM_3: ["q1", "q2", "q3", "q4", "year"],
+        FormTypeEnum.FORM_4: ["plan", "seq_dfip", "approved", "contract", "booking", "q1", "q2", "q3", "q4", "totals", "contract_summary", "allocation", "reserve", "collegial", "ckk"],
+    }
+
+    _sheet_list_with_directions = {
+        FormTypeEnum.FORM_1: [
+            {
+                "sheet_name": sheet_name,
+                "direction": None,
+            } for sheet_name in ["OPER", "SMETA"]
+        ] + [
+            {
+                "sheet_name": sheet_name,
+                "direction": direction
+            } for sheet_name in ["AHR", "CAP"] for direction in ["Support", "Development"]
+        ]
+    }
+
+    @property
+    def sheet_list_with_directions(self) -> dict:
+        return self._sheet_list_with_directions.get(
+            self.code,
+            [
+                {
+                    "sheet_name": sheet_name,
+                    "direction": None,
+                } for sheet_name in self.sheet_list
+            ]
+        )
+
+    @property
+    def sheet_list(self):
+        return self.SHEETS_BY_FORM_TYPE.get(self.code, [])
+
+    @property
+    def section_list(self):
+        return self.SECTIONS_BY_FORM_TYPE.get(self.code, [])

api/src/db/models/limit_template.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, ForeignKey, Index, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class LimitTemplate(Base):
+    __tablename__ = "limit_template"
+    __table_args__ = (
+        CheckConstraint(
+            "row_type IN ('SECTION','GROUP','LEAF')",
+            name="ck_v3_limit_template_row_type",
+        ),
+        Index("ix_v3_limit_template_parent", "parent_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    parent_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.limit_template.id"))
+    sort_order: Mapped[int] = mapped_column(Integer)
+    row_type: Mapped[str] = mapped_column(String)
+    section_no: Mapped[str | None] = mapped_column(String)
+    expense_item_code: Mapped[str | None] = mapped_column(String)
+    name: Mapped[str] = mapped_column(String)
+    unit: Mapped[str | None] = mapped_column(String)
+    limit_with_vat: Mapped[float | None] = mapped_column(Numeric)
+    limit_without_vat: Mapped[float | None] = mapped_column(Numeric)
+
+#     parent = relationship("LimitTemplate", remote_side="LimitTemplate.id")
+#     children: Mapped[list[LimitTemplate]] = relationship("LimitTemplate")
+#     form_limits: Mapped[list[FormLimit]] = relationship("FormLimit")

api/src/db/models/org_unit.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from sqlalchemy import Boolean, Index, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class OrgUnit(Base):
+    __tablename__ = "org_unit"
+    __table_args__ = (
+        Index(
+            "ix_v4_org_unit_active",
+            "is_active",
+            postgresql_where="is_active",
+        ),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    title: Mapped[str] = mapped_column(String)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    is_ssp: Mapped[bool] = mapped_column(Boolean)
+
+    @property
+    def users_count(self) -> int | None:
+        return len(self.users) if self.users is not None else None
+
+
+#     budget_forms: Mapped[list["BudgetForm"]] = relationship(  # type: ignore
+#         "BudgetForm", back_populates="org_unit"
+#     )
+#     audit_logs: Mapped[list["AuditLog"]] = relationship(  # type: ignore
+#         "AuditLog", back_populates="org_unit"
+#     )
+#     projects: Mapped[list["Project"]] = relationship(  # type: ignore
+#         "Project", back_populates="org_unit"
+#     )
+#     vsps: Mapped[list["Vsp"]] = relationship("Vsp", back_populates="org_unit")  # type: ignore
+    user_orgs: Mapped[list["UserOrg"]] = relationship("UserOrg", back_populates="org_unit")
+    users: Mapped[list["AppUser"]] = relationship("AppUser", secondary="v3.user_org", back_populates="org_units")

api/src/db/models/phase_template.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import ARRAY, CheckConstraint, DateTime, ForeignKey, String, Text, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class PhaseTemplate(Base):
+    __tablename__ = "phase_template"
+    __table_args__ = (
+        CheckConstraint(text("cardinality(column_keys) > 0"), name="chk_v4_phase_template_columns"),
+        CheckConstraint(text("role != 'ADMIN'"), name="chk_v4_phase_template_no_admin"),
+        CheckConstraint(text("closes_at > opens_at"), name="chk_v4_phase_template_window"),
+        {"schema": "v3"},
+    )
+
+    form_type: Mapped[str] = mapped_column(String, ForeignKey("v3.form_type.code"), primary_key=True)
+    sheet: Mapped[str] = mapped_column(String, primary_key=True)
+    phase_code: Mapped[str] = mapped_column(String, primary_key=True)
+    role: Mapped[str] = mapped_column(String, ForeignKey("v3.role.code"))
+    column_keys: Mapped[list[str]] = mapped_column(ARRAY(Text))
+    opens_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+    closes_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+
+#     form_type_rel = relationship("FormType", foreign_keys=[form_type])
+#     role_rel = relationship("Role", foreign_keys=[role], back_populates="phase_templates")

api/src/db/models/plan.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Plan(Base):
+    __tablename__ = "plan"
+    __table_args__ = {"schema": "v3"}
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    plan_q1: Mapped[float | None] = mapped_column(Numeric)
+    plan_q2: Mapped[float | None] = mapped_column(Numeric)
+    plan_q3: Mapped[float | None] = mapped_column(Numeric)
+    plan_q4: Mapped[float | None] = mapped_column(Numeric)
+    comment: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine", uselist=False)

api/src/db/models/project.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, ForeignKey, Index, Integer, Numeric, String, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Project(Base):
+    __tablename__ = "project"
+    __table_args__ = (
+        CheckConstraint("level IN ('program', 'project')", name="project_level_check"),
+        CheckConstraint(
+            "placement_type IS NULL OR placement_type IN ('own', 'rent', 'other')",
+            name="project_placement_type_check",
+        ),
+        CheckConstraint(
+            "project_type IS NULL OR project_type IN ('current', 'development')",
+            name="project_project_type_check",
+        ),
+        CheckConstraint(
+            "vsp_format IS NULL OR vsp_format IN ('office', 'standalone', 'atm', 'other')",
+            name="project_vsp_format_check",
+        ),
+        CheckConstraint(
+            text("name IS NOT NULL AND name <> ''"),
+            name="chk_v3_project_name",
+        ),
+        Index("ix_v3_project_ssp", "org_unit_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str | None] = mapped_column(String)
+    level: Mapped[str | None] = mapped_column(String)
+    parent_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.project.id"))
+    project_type: Mapped[str | None] = mapped_column(String)
+    vsp_format: Mapped[str | None] = mapped_column(String)
+    placement_type: Mapped[str | None] = mapped_column(String)
+    object_address: Mapped[str | None] = mapped_column(String)
+    staff_count: Mapped[int | None] = mapped_column(Integer)
+    total_area: Mapped[float | None] = mapped_column(Numeric)
+    org_unit_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.org_unit.id"))
+
+#     parent = relationship("Project", remote_side="Project.id", back_populates="children")
+#     children: Mapped[list["Project"]] = relationship("Project", back_populates="parent")  # type: ignore
+#     org_unit = relationship("OrgUnit", back_populates="projects")
+#     budget_lines: Mapped[list["BudgetLine"]] = relationship("BudgetLine", back_populates="project")  # type: ignore
+#     rf_project_reports: Mapped[list["RfProjectReport"]] = relationship("RfProjectReport", back_populates="project")  # type: ignore

api/src/db/models/rent_detail.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from datetime import date
+
+from sqlalchemy import Date, ForeignKey, Index, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class RentDetail(Base):
+    __tablename__ = "rent_detail"
+    __table_args__ = (
+        Index("ix_v3_rent_detail_line", "line_id"),
+        Index("ix_v3_rent_detail_vsp", "vsp_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"))
+    vsp_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.vsp.id"))
+    contract_number: Mapped[str | None] = mapped_column(String)
+    contract_end_date: Mapped[date | None] = mapped_column(Date)
+    plan_q1: Mapped[float | None] = mapped_column(Numeric)
+    plan_q2: Mapped[float | None] = mapped_column(Numeric)
+    plan_q3: Mapped[float | None] = mapped_column(Numeric)
+    plan_q4: Mapped[float | None] = mapped_column(Numeric)
+    actual_jan: Mapped[float | None] = mapped_column(Numeric)
+    actual_feb: Mapped[float | None] = mapped_column(Numeric)
+    actual_mar: Mapped[float | None] = mapped_column(Numeric)
+    actual_apr: Mapped[float | None] = mapped_column(Numeric)
+    actual_may: Mapped[float | None] = mapped_column(Numeric)
+    actual_jun: Mapped[float | None] = mapped_column(Numeric)
+    actual_jul: Mapped[float | None] = mapped_column(Numeric)
+    actual_aug: Mapped[float | None] = mapped_column(Numeric)
+    actual_sep: Mapped[float | None] = mapped_column(Numeric)
+    actual_oct: Mapped[float | None] = mapped_column(Numeric)
+    actual_nov: Mapped[float | None] = mapped_column(Numeric)
+    actual_dec: Mapped[float | None] = mapped_column(Numeric)
+    comment: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine")
+#     vsp = relationship("Vsp")

api/src/db/models/reserve.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Reserve(Base):
+    __tablename__ = "reserve"
+    __table_args__ = {"schema": "v3"}
+
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"), primary_key=True)
+    amount_q1: Mapped[float | None] = mapped_column(Numeric)
+    amount_q2: Mapped[float | None] = mapped_column(Numeric)
+    amount_q3: Mapped[float | None] = mapped_column(Numeric)
+    amount_q4: Mapped[float | None] = mapped_column(Numeric)
+    justification: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine", uselist=False)

api/src/db/models/rf_project_report.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, Integer, String, UniqueConstraint, func
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class RfProjectReport(Base):
+    __tablename__ = "rf_project_report"
+    __table_args__ = (
+        UniqueConstraint("project_id", "year", "report_type", name="uq_v3_rf_project_report"),
+        Index("ix_v3_rf_project_report_proj_year", "project_id", "year"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    project_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.project.id"))
+    year: Mapped[int] = mapped_column(Integer)
+    report_type: Mapped[str] = mapped_column(String, CheckConstraint("report_type IN ('LIMIT','CURRENT_EXPENSES')"))
+    created_by: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.app_user.id"))
+    created_at: Mapped[datetime | None] = mapped_column(DateTime, server_default=func.now())
+    updated_by: Mapped[int | None] = mapped_column(Integer, ForeignKey("v3.app_user.id"))
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime, server_default=func.now())
+
+#     project: Mapped[Project] = relationship("Project", back_populates="rf_project_reports")
+#     creator: Mapped[AppUser | None] = relationship("AppUser", foreign_keys=[created_by])
+#     updater: Mapped[AppUser | None] = relationship("AppUser", foreign_keys=[updated_by])
+#     lines: Mapped[list[RfProjectReportLine]] = relationship("RfProjectReportLine", back_populates="report")

api/src/db/models/rf_project_report_line.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from sqlalchemy import ForeignKey, Index, Integer, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class RfProjectReportLine(Base):
+    __tablename__ = "rf_project_report_line"
+    __table_args__ = (
+        UniqueConstraint(
+            "rf_project_report_id", "expense_item_id", name="uq_v3_rf_project_report_line"
+        ),
+        Index("ix_v3_rf_project_report_line_rep", "rf_project_report_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    rf_project_report_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.rf_project_report.id"))
+    expense_item_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.expense_item.id"))
+
+#     report: Mapped[RfProjectReport] = relationship("RfProjectReport", back_populates="lines")
+#     expense_item: Mapped[ExpenseItem] = relationship("ExpenseItem")
+#     quarters: Mapped[list[RfProjectReportQuarter]] = relationship(
+#         "RfProjectReportQuarter", back_populates="line"
+#     )

api/src/db/models/rf_project_report_quarter.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, ForeignKey, Integer, Numeric, SmallInteger
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class RfProjectReportQuarter(Base):
+    __tablename__ = "rf_project_report_quarter"
+    __table_args__ = {"schema": "v3"}
+
+    rf_project_report_line_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("v3.rf_project_report_line.id"), primary_key=True
+    )
+    quarter: Mapped[int] = mapped_column(
+        SmallInteger,
+        CheckConstraint("quarter >= 1 AND quarter <= 4"),
+        primary_key=True,
+    )
+    adj_by_items: Mapped[float | None] = mapped_column(Numeric)
+    adj_increase: Mapped[float | None] = mapped_column(Numeric)
+    actual_m1: Mapped[float | None] = mapped_column(Numeric)
+    actual_m2: Mapped[float | None] = mapped_column(Numeric)
+    actual_m3: Mapped[float | None] = mapped_column(Numeric)
+    actual_spod: Mapped[float | None] = mapped_column(Numeric)
+
+#     line: Mapped[RfProjectReportLine] = relationship(
+#         "RfProjectReportLine", back_populates="quarters"
+#     )

api/src/db/models/role.py

@@ -0,0 +1,31 @@
+import enum
+
+from sqlalchemy import String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class UserRoleEnum(int, enum.Enum):
+    ADMIN = 1
+    EXECUTOR_DFIP = 2
+    EXECUTOR_RF = 3
+
+
+class Role(Base):
+    __tablename__ = "role"
+    __table_args__ = (
+        UniqueConstraint("code", name="uq_role_code"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    code: Mapped[str] = mapped_column(String)
+
+#     users: Mapped[list["AppUser"]] = relationship("AppUser", back_populates="role")  # type: ignore
+#     form_phases: Mapped[list["FormPhase"]] = relationship(  # type: ignore
+#         "FormPhase", back_populates="role"
+#     )
+#     phase_templates: Mapped[list["PhaseTemplate"]] = relationship(  # type: ignore
+#         "PhaseTemplate", back_populates="role"
+#     )

api/src/db/models/security_detail.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from datetime import date
+
+from sqlalchemy import Date, ForeignKey, Index, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class SecurityDetail(Base):
+    __tablename__ = "security_detail"
+    __table_args__ = (
+        Index("ix_v3_security_detail_line", "line_id"),
+        Index("ix_v3_security_detail_vsp", "vsp_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"))
+    vsp_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.vsp.id"))
+    contract_number: Mapped[str | None] = mapped_column(String)
+    contract_end_date: Mapped[date | None] = mapped_column(Date)
+    plan_q1: Mapped[float | None] = mapped_column(Numeric)
+    plan_q2: Mapped[float | None] = mapped_column(Numeric)
+    plan_q3: Mapped[float | None] = mapped_column(Numeric)
+    plan_q4: Mapped[float | None] = mapped_column(Numeric)
+    actual_jan: Mapped[float | None] = mapped_column(Numeric)
+    actual_feb: Mapped[float | None] = mapped_column(Numeric)
+    actual_mar: Mapped[float | None] = mapped_column(Numeric)
+    actual_apr: Mapped[float | None] = mapped_column(Numeric)
+    actual_may: Mapped[float | None] = mapped_column(Numeric)
+    actual_jun: Mapped[float | None] = mapped_column(Numeric)
+    actual_jul: Mapped[float | None] = mapped_column(Numeric)
+    actual_aug: Mapped[float | None] = mapped_column(Numeric)
+    actual_sep: Mapped[float | None] = mapped_column(Numeric)
+    actual_oct: Mapped[float | None] = mapped_column(Numeric)
+    actual_nov: Mapped[float | None] = mapped_column(Numeric)
+    actual_dec: Mapped[float | None] = mapped_column(Numeric)
+    comment: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine")
+#     vsp = relationship("Vsp")

api/src/db/models/sequestration.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from sqlalchemy import CheckConstraint, ForeignKey, Index, Integer, Numeric, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Sequestration(Base):
+    __tablename__ = "sequestration"
+    __table_args__ = (
+        CheckConstraint("actor IN ('DFIP','SSP_GO')", name="ck_v3_sequestration_actor"),
+        UniqueConstraint("line_id", "actor", name="uq_v3_sequestration_line_actor"),
+        Index("ix_v3_sequestration_line_actor", "line_id", "actor"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"))
+    actor: Mapped[str] = mapped_column(String)
+    adj_q1: Mapped[float | None] = mapped_column(Numeric)
+    adj_q2: Mapped[float | None] = mapped_column(Numeric)
+    adj_q3: Mapped[float | None] = mapped_column(Numeric)
+    adj_q4: Mapped[float | None] = mapped_column(Numeric)
+    justification: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine")

api/src/db/models/user_org.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from sqlalchemy import ForeignKey, Index, Integer, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class UserOrg(Base):
+    __tablename__ = "user_org"
+    __table_args__ = (
+        UniqueConstraint("user_id", "org_unit_id"),
+        Index("ix_v4_user_org_org", "org_unit_id"),
+        Index("ix_v4_user_org_user", "user_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.app_user.id", ondelete="CASCADE"))
+    org_unit_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.org_unit.id", ondelete="CASCADE"))
+
+    user: Mapped[AppUser] = relationship("AppUser", back_populates="user_orgs", lazy="selectin")
+    org_unit: Mapped[OrgUnit] = relationship("OrgUnit", back_populates="user_orgs", lazy="selectin")

api/src/db/models/utility_detail.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from datetime import date
+
+from sqlalchemy import Date, ForeignKey, Index, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class UtilityDetail(Base):
+    __tablename__ = "utility_detail"
+    __table_args__ = (
+        Index("ix_v3_utility_detail_line", "line_id"),
+        Index("ix_v3_utility_detail_vsp", "vsp_id"),
+        {"schema": "v3"},
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    line_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.budget_line.id"))
+    vsp_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.vsp.id"))
+    contract_number: Mapped[str | None] = mapped_column(String)
+    contract_end_date: Mapped[date | None] = mapped_column(Date)
+    plan_q1: Mapped[float | None] = mapped_column(Numeric)
+    plan_q2: Mapped[float | None] = mapped_column(Numeric)
+    plan_q3: Mapped[float | None] = mapped_column(Numeric)
+    plan_q4: Mapped[float | None] = mapped_column(Numeric)
+    actual_jan: Mapped[float | None] = mapped_column(Numeric)
+    actual_feb: Mapped[float | None] = mapped_column(Numeric)
+    actual_mar: Mapped[float | None] = mapped_column(Numeric)
+    actual_apr: Mapped[float | None] = mapped_column(Numeric)
+    actual_may: Mapped[float | None] = mapped_column(Numeric)
+    actual_jun: Mapped[float | None] = mapped_column(Numeric)
+    actual_jul: Mapped[float | None] = mapped_column(Numeric)
+    actual_aug: Mapped[float | None] = mapped_column(Numeric)
+    actual_sep: Mapped[float | None] = mapped_column(Numeric)
+    actual_oct: Mapped[float | None] = mapped_column(Numeric)
+    actual_nov: Mapped[float | None] = mapped_column(Numeric)
+    actual_dec: Mapped[float | None] = mapped_column(Numeric)
+    comment: Mapped[str | None] = mapped_column(String)
+
+#     line = relationship("BudgetLine")
+#     vsp = relationship("Vsp")

api/src/db/models/vsp.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from datetime import date
+
+from sqlalchemy import Date, ForeignKey, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.base import Base
+
+
+class Vsp(Base):
+    __tablename__ = "vsp"
+    __table_args__ = {"schema": "v3"}
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    branch_id: Mapped[int] = mapped_column(Integer, ForeignKey("v3.org_unit.id"))
+    reg_number: Mapped[str | None] = mapped_column(String)
+    address: Mapped[str | None] = mapped_column(String)
+    format: Mapped[str | None] = mapped_column(String)
+    opened_at: Mapped[date | None] = mapped_column(Date)
+    placement_type: Mapped[str | None] = mapped_column(String)
+    staff_count: Mapped[int | None] = mapped_column(Integer)
+    total_area: Mapped[float | None] = mapped_column(Numeric)
+    closed_at: Mapped[date | None] = mapped_column(Date)
+
+#     org_unit = relationship("OrgUnit", back_populates="vsps")
+#     budget_lines: Mapped[list["BudgetLine"]] = relationship("BudgetLine", back_populates="vsp")  # type: ignore
+#     rent_details: Mapped[list["RentDetail"]] = relationship("RentDetail", back_populates="vsp")
+#     security_details: Mapped[list["SecurityDetail"]] = relationship("SecurityDetail", back_populates="vsp")
+#     utility_details: Mapped[list["UtilityDetail"]] = relationship("UtilityDetail", back_populates="vsp")

api/src/db/session.py

@@ -5,6 +5,8 @@ from alembic import command
 from alembic.config import Config
 
 from src.core.config import settings
+from typing import AsyncGenerator
+
 from src.db.base import SessionLocal
 
 
@@ -12,6 +14,10 @@ async def get_db() -> AsyncGenerator:
     db = SessionLocal()
     try:
         yield db
+        await db.commit()
+    except Exception:
+        await db.rollback()
+        raise
     finally:
         await db.close()
 

api/src/domain/models.py

@@ -1,70 +0,0 @@
-import enum
-
-from sqlalchemy import (Boolean, Column, DateTime, ForeignKey, Integer, String,
-                        UniqueConstraint)
-from sqlalchemy.orm import relationship
-from sqlalchemy.sql import func
-
-from src.db.base import Base
-
-
-class UserRole(int, enum.Enum):
-    ADMIN = 1
-    EXECUTOR_DFIP = 2
-    EXECUTOR_RF = 3
-
-
-class Roles(Base):
-    __tablename__ = "roles"
-
-    id = Column(Integer, primary_key=True, index=True)
-    role = Column(String, nullable=False)
-
-    user_role = relationship("Users", back_populates="role", lazy="select")
-
-
-class Users(Base):
-    __tablename__ = "users"
-
-    id = Column(Integer, primary_key=True, index=True)
-    email = Column(String, unique=True, index=True, nullable=False)
-    username = Column(String, unique=True, index=True, nullable=False)
-    hashed_password = Column(String, nullable=True)
-    full_name = Column(String, nullable=True)
-    role_id = Column(Integer, ForeignKey("roles.id"), nullable=False)
-    created_at = Column(DateTime(timezone=True), server_default=func.now())
-    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
-    is_active = Column(Boolean, default=True, nullable=False, server_default="true")
-
-    role = relationship(
-        "Roles",
-        foreign_keys=[role_id],
-        back_populates="user_role",
-        lazy="selectin",
-    )
-    user_ssp_link = relationship("UserSSPLink", back_populates="users", lazy="select")
-
-
-class SSP(Base):
-    __tablename__ = "ssp"
-
-    id = Column(Integer, primary_key=True, index=True)
-    title = Column(String, nullable=False)
-    is_active = Column(Boolean, default=True, nullable=False, server_default="true")
-    is_ssp = Column(Boolean, default=True, nullable=False, server_default="true")
-
-    user_ssp_link = relationship("UserSSPLink", back_populates="ssp", lazy="select")
-
-
-class UserSSPLink(Base):
-    __tablename__ = "user_ssp_link"
-    __table_args__ = (
-        UniqueConstraint("user_id", "ssp_id", name="uq_user_ssp_link_user_id_ssp_id"),
-    )
-
-    id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
-    ssp_id = Column(Integer, ForeignKey("ssp.id"), nullable=False)
-
-    users = relationship("Users", back_populates="user_ssp_link", lazy="select")
-    ssp = relationship("SSP", back_populates="user_ssp_link", lazy="select")

api/src/domain/schemas.py

@@ -1,41 +1,124 @@
 from datetime import datetime
-from typing import Optional
+import enum
+from typing import Any, Dict, Generic, List, Literal, Optional, TypeVar
+from sqlalchemy.exc import MissingGreenlet
 
-from pydantic import BaseModel, ConfigDict, EmailStr, Field
+FormPhaseRole = Literal["DFIP", "EXECUTOR_RF"]
+
+
+from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator, model_validator
+
+T = TypeVar("T")
+
+ProjectTypeLiteral = Literal[
+    "Открытие ВСП",
+    "Закрытие ВСП",
+    "Переезд ВСП",
+    "Реновация РФ",
+    "Открытие УРМ",
+]
+
+VspFormatLiteral = Literal[
+    "Флагманский",
+    "Типовой",
+    "Розничный",
+    "МСБ",
+    "Лёгкий",
+    "Мини",
+    "Розничный-киоск",
+    "МБО",
+    "Офис самообслуживания",
+    "Другое",
+]
+
+PlacementTypeLiteral = Literal[
+    "Собственность",
+    "Аренда",
+    "Субаренда",
+]
+
+
+# def serialize_missing_greenlet(cls, obj):
+#     result = {}
+#     for attr in cls.model_fields:
+#         try:
+#             result[attr] = getattr(obj, attr)
+#         except MissingGreenlet:
+#             result[attr] = None
+#     return result
 
 
 class ResponseBase(BaseModel):
-    success: Optional[bool] = Field(None)
-    message: Optional[str] = Field(None)
+    success: Optional[bool] = Field(True)
+    message: Optional[str] = None
+
+
+class BaseSingleResponse(ResponseBase, Generic[T]):
+    result: Optional[T] = None
+
+
+class BaseListResponse(ResponseBase, Generic[T]):
+    result: Optional[list[T]] = None
+    count: Optional[int] = None
 
 
 class UserBase(BaseModel):
-    email: EmailStr
+    email: EmailStr = Field(..., examples=["user@example.com"])
     username: str = Field(
         ...,
         min_length=3,
         max_length=64,
         pattern=r"^[A-Za-z0-9_.-]+$",
+        examples=["user_1"],
+    )
+    full_name: Optional[str] = Field(
+        None,
+        max_length=255,
+        pattern=r"^[^<>]*$",
+        examples=["Иван Иванов"],
     )
-    full_name: Optional[str] = Field(None, max_length=255, pattern=r"^[^<>]*$")
     role_id: int = 3
 
+    model_config = ConfigDict(from_attributes=True)
+
+
 
 class UserCreate(UserBase):
-    password: str | None = None
+    password: str | None = Field(default=None, examples=["pass123"])
+    load_orgs: bool = Field(default=False)
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "email": "user@example.com",
+                "username": "user_1",
+                "full_name": "Иван Иванов",
+                "role_id": 3,
+                "password": "pass123",
+                "load_orgs": True,
+            }
+        }
+    )
 
 
 class UserUpdate(BaseModel):
-    email: Optional[EmailStr] = None
+    email: Optional[EmailStr] = Field(default=None, examples=["user@example.com"])
     username: Optional[str] = Field(
         None,
         min_length=3,
         max_length=64,
         pattern=r"^[A-Za-z0-9_.-]+$",
+        examples=["user_1"],
+    )
+    full_name: Optional[str] = Field(
+        None,
+        max_length=255,
+        pattern=r"^[^<>]*$",
+        examples=["Иван Иванов"],
     )
-    full_name: Optional[str] = Field(None, max_length=255, pattern=r"^[^<>]*$")
     role_id: Optional[int] = None
     is_active: Optional[bool] = True
+    load_orgs: bool = Field(default=False)
 
 
 class UserInDB(UserBase):
@@ -51,6 +134,37 @@ class User(UserInDB):
     pass
 
 
+class UserAdminListResponse(UserInDB):
+    org_units: Optional[list["OrgUnitSchema"]] = None
+
+
+    @model_validator(mode='before')
+    @classmethod
+    def safe_orm_handler(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            return data
+        result = {
+            "org_units": None,
+            "id": data.id,
+            "created_at": data.created_at,
+            "updated_at": data.updated_at,
+            "is_active": data.is_active,
+            "email": data.email,
+            "username": data.username,
+            "full_name": data.full_name,
+            "role_id": data.role_id,
+        }
+        try:
+            result["org_units"] = [
+                ou for ou in data.org_units
+                if ou.is_active
+            ]
+        except MissingGreenlet:
+            pass
+
+        return result
+
+
 class UserResponse(ResponseBase):
     result: Optional[UserInDB] = None
 
@@ -97,3 +211,243 @@ class LoginRequest(BaseModel):
 
 class RefreshRequest(BaseModel):
     refresh_token: str
+
+
+class FormTypeSchemaEnum(str, enum.Enum):
+    FORM_1 = "FORM_1"
+    FORM_2 = "FORM_2"
+    FORM_3 = "FORM_3"
+    FORM_4 = "FORM_4"
+
+
+class OrgUnitBaseSchema(BaseModel):
+    title: str
+    is_ssp: bool
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class OrgUnitUpdateSchema(OrgUnitBaseSchema):
+    title: Optional[str] = None
+    is_ssp: Optional[bool] = None
+    is_active: Optional[bool] = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class OrgUnitResponseSchema(OrgUnitBaseSchema):
+    id: int
+    is_active: bool
+    users_count: int | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+    @model_validator(mode='before')
+    @classmethod
+    def safe_orm_handler(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            return data
+        result = {
+            "users_count": None,
+            "id": data.id,
+            "title": data.title,
+            "is_ssp": data.is_ssp,
+            "is_ssp": data.is_ssp,
+            "is_active": data.is_active,
+        }
+        try:
+            result["users_count"] = data.users_count
+        except MissingGreenlet:
+            pass
+
+        return result
+
+
+class OrgUnitListSchema(OrgUnitResponseSchema):
+    pass
+
+
+class OrgUnitSchema(OrgUnitResponseSchema):
+    users: list[UserBase] | None = None
+
+    @model_validator(mode='before')
+    @classmethod
+    def safe_orm_handler(cls, data: Any) -> Any:
+        if isinstance(data, dict):
+            return data
+        result = super().safe_orm_handler(data)
+        result["users"] = None
+        try:
+            result["users"] = data.users
+        except MissingGreenlet:
+            pass
+
+        return result
+
+
+class BudgetFormResponse(BaseModel):
+    id: int
+    created_at: datetime
+    created_by: int | None
+    updated_at: datetime
+    form_type_code: FormTypeSchemaEnum
+    year: int
+    org_unit_id: int
+    org_unit: OrgUnitSchema | None = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class FullSheetSchema(BaseModel):
+    sheet_name: str
+    direction: str | None = None
+
+
+class SheetFormTypeResponse(BaseModel):
+    form_type: FormTypeSchemaEnum
+    sheets: list[str]
+    all_sheets: list[FullSheetSchema] | None = None
+
+
+class DirectionSchemaEnum(str, enum.Enum):
+    SUPPORT = "Support"
+    DEVELOPMENT = "Development"
+
+
+class SheetResponse(BaseModel):
+    row_type: str
+    depth: int
+    data: dict
+    sort_order: int | None = None
+
+
+class CellPatch(BaseModel):
+    line_id: int
+    column: str
+    value: Any = None
+
+
+class CellsPatch(BaseModel):
+    changes: list[CellPatch]
+
+
+class ExportBulkRequest(BaseModel):
+    form_ids: list[int] = Field(min_length=1)
+    skip_failed: bool = True
+
+
+class AddForm3LineBody(BaseModel):
+    expense_item_id: int
+
+
+class UpdProjectBody(BaseModel):
+    column: str
+    value: Any = None
+
+
+class AddProjectBody(BaseModel):
+    name: str = Field(
+        ...,
+        max_length=30,
+        pattern=r"^[^+\-\/\\=&*\s]{1,30}$",
+    )
+    year: int
+    branch_id: int
+    level: Literal["project", "program"] = "project"
+    parent_id: Optional[int] = None
+    ssp_id: Optional[int] = None
+    project_type: Optional[ProjectTypeLiteral] = None
+    vsp_format: Optional[VspFormatLiteral] = None
+    placement_type: Optional[PlacementTypeLiteral] = None
+    object_address: Optional[str] = None
+    staff_count: Optional[int] = None
+    total_area: Optional[float] = None
+
+
+class AddLineSchema(BaseModel):
+    expense_item_id: Optional[int] = None
+    item_id: Optional[str] = None
+    section_code: Optional[str] = None
+    direction: Optional[DirectionSchemaEnum] = None
+    name: Optional[str] = None
+    internal_order: Optional[str] = None
+    vsp_id: Optional[int] = None
+    project_id: Optional[int] = None
+    justification: Optional[str] = None
+    contract_number: Optional[str] = None
+    contract_end_date: Optional[datetime] = None
+
+
+class FormPhaseResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    budget_form_id: int
+    sheet: str
+    phase_code: str
+    role: str
+    column_keys: list[str]
+    opens_at: datetime
+    closes_at: datetime
+
+
+class FormPhaseCreate(BaseModel):
+    sheet: str
+    phase_code: str
+    role: FormPhaseRole
+    column_keys: list[str]
+    opens_at: datetime
+    closes_at: datetime
+
+
+class FormPhaseUpdate(BaseModel):
+    role: FormPhaseRole | None = None
+    column_keys: list[str] | None = None
+    opens_at: datetime | None = None
+    closes_at: datetime | None = None
+
+
+class AuditLogBase(BaseModel):
+    """Базовая схема записи аудита (единый формат вывода как у auditlog)."""
+
+    entity: str = Field(..., description="Тип сущности")
+    entity_id: Optional[int] = Field(None, description="ID сущности")
+    action: str = Field(..., description="Действие")
+    payload_json: Optional[Dict[str, Any]] = None
+
+
+class AuditLogInDB(AuditLogBase):
+    """Схема записи аудита в базе данных."""
+
+    model_config = ConfigDict(from_attributes=True)
+    id: int = Field(..., description="ID записи")
+    user_id: Optional[int] = Field(None, description="ID пользователя")
+    at: datetime = Field(..., description="Дата/время события")
+
+
+class AuditLog(AuditLogInDB):
+    """Схема записи аудита для ответа API."""
+
+    user: Optional[User] = None
+
+
+class AuditLogListResponse(ResponseBase):
+    """Схема всех записей аудита для ответа API."""
+
+    result: List[AuditLog] = Field(..., description="Вывод записей аудита")
+
+
+class AuditLogQueryParams(BaseModel):
+    """Query-параметры для фильтрации журнала аудита."""
+
+    page: int = Field(1, ge=1, description="Номер страницы")
+    limit: int = Field(
+        20, ge=1, le=100, description="Количество записей на странице"
+    )
+    user_id: Optional[int] = Field(None, description="ID пользователя")
+    org_unit_id: Optional[int] = Field(None, description="ID ССП")
+    task_id: Optional[int] = Field(None, description="ID задачи")
+    form_id: Optional[int] = Field(None, description="ID формы")
+    event_type: Optional[str] = Field(None, description="Тип события")
+    date_from: Optional[datetime] = Field(None, description="Дата начала (ISO 8601)")
+    date_to: Optional[datetime] = Field(None, description="Дата окончания (ISO 8601)")

api/src/main.py

@@ -1,9 +1,13 @@
+import asyncio
 import os
 from contextlib import asynccontextmanager
 from datetime import datetime, timezone
+from contextlib import suppress
 
-from fastapi import FastAPI
+from fastapi import FastAPI, Response
 from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy import text
+from sqlalchemy.exc import SQLAlchemyError
 from fastapi.staticfiles import StaticFiles
 from starlette.middleware.gzip import GZipMiddleware
 from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
@@ -25,8 +29,72 @@ if not settings.DEBUG:
     )
 
 
+_AUDIT_CLEANUP_LOCK_KEY = 21987431
+
+
+async def _cleanup_audit_log_once() -> int:
+    if "postgresql" not in settings.DATABASE_URL:
+        return 0
+
+    total_deleted = 0
+    async with engine.begin() as conn:
+        lock_ok = (
+            await conn.execute(
+                text("SELECT pg_try_advisory_lock(:k)"),
+                {"k": _AUDIT_CLEANUP_LOCK_KEY},
+            )
+        ).scalar_one()
+        if not lock_ok:
+            return 0
+        try:
+            while True:
+                deleted = (
+                    await conn.execute(
+                        text(
+                            """
+                            WITH doomed AS (
+                                SELECT id
+                                FROM v3.audit_log
+                                WHERE event_dt < now() - make_interval(days => :retention_days)
+                                ORDER BY id
+                                LIMIT :batch_size
+                            )
+                            DELETE FROM v3.audit_log a
+                            USING doomed d
+                            WHERE a.id = d.id
+                            RETURNING a.id
+                            """
+                        ),
+                        {
+                            "retention_days": settings.AUDIT_LOG_RETENTION_DAYS,
+                            "batch_size": settings.AUDIT_LOG_CLEANUP_BATCH_SIZE,
+                        },
+                    )
+                ).rowcount
+                if not deleted:
+                    break
+                total_deleted += deleted
+        finally:
+            await conn.execute(
+                text("SELECT pg_advisory_unlock(:k)"),
+                {"k": _AUDIT_CLEANUP_LOCK_KEY},
+            )
+    return total_deleted
+
+
+async def _audit_cleanup_loop() -> None:
+    # Первый прогон сразу после старта, дальше — по интервалу.
+    while True:
+        try:
+            await _cleanup_audit_log_once()
+        except Exception:
+            pass
+        await asyncio.sleep(max(60, settings.AUDIT_LOG_CLEANUP_INTERVAL_SECONDS))
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    cleanup_task: asyncio.Task | None = None
     if not settings.DEBUG:
         await create_tables()
         ProtectedSettings(
@@ -36,9 +104,14 @@ async def lifespan(app: FastAPI):
                 APP_NAME=settings.APP_NAME,
             ),
         )
+        cleanup_task = asyncio.create_task(_audit_cleanup_loop())
     try:
         yield
     finally:
+        if cleanup_task:
+            cleanup_task.cancel()
+            with suppress(asyncio.CancelledError):
+                await cleanup_task
         await engine.dispose()
 
 
@@ -69,6 +142,41 @@ async def healthcheck2():
         "port": settings.PORT,
     }
 
+@app.get("/healthz", status_code=200)
+async def healthz():
+    return {"status": "ok", "uptime": UP_TIME, "version": VERSION}
+
+
+@app.get("/readyz")
+async def readyz(response: Response):
+    result = {"status": "ok", "db_status": "ok", "mv_expense_item_tree": "ok"}
+    try:
+        async with engine.connect() as conn:
+            await conn.execute(text("SELECT 1"))
+            if "postgresql" in settings.DATABASE_URL:
+                my_exists = (
+                    await conn.execute(
+                        text(
+                            """
+                            SELECT 1
+                            FROM pg_matviews
+                            WHERE schemaname = 'v3' 
+                              AND matviewname = 'mv_expense_item_tree'
+                            """
+                        )
+                    )
+                ).scalar_one_or_none()
+                if my_exists is None:
+                    result["status"] = "fail"
+                    result["mv_expense_item_tree"] = "missing"
+                    response.status_code = 503
+    except SQLAlchemyError as exc:
+        result["status"] = "fail"
+        result["db"] = f"error: {exc.__class__.__name__}"
+        response.status_code = 503
+    return result
+
+
 
 if not settings.DEBUG:
     app.add_middleware(
@@ -83,6 +191,16 @@ if not settings.DEBUG:
                 path=settings.ROOT_PATH + "/healthcheck",
                 type_search=SearchType.ABSOLUTE,
             ),
+            OpenEndpoint(path="/healthz", type_search=SearchType.ABSOLUTE),
+            OpenEndpoint(
+                path=settings.ROOT_PATH + "/healthz",
+                type_search=SearchType.ABSOLUTE,
+            ),
+            OpenEndpoint(path="/readyz", type_search=SearchType.ABSOLUTE),
+            OpenEndpoint(
+                path=settings.ROOT_PATH + "/readyz",
+                type_search=SearchType.ABSOLUTE,
+            ),
             OpenEndpoint(path="/openapi.json", type_search=SearchType.START),
             OpenEndpoint(
                 path=settings.ROOT_PATH + "/openapi.json",

api/src/repository/auditlog_repository.py

@@ -0,0 +1,83 @@
+from datetime import datetime
+from typing import Iterable, Optional
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.sql.functions import func
+from sqlalchemy.orm import joinedload
+
+# from sqlalchemy.orm import selectinload
+
+# from app.domain.models import AuditLog
+from src.db.models.audit_log import AuditLog
+
+
+class AuditLogRepository:
+    """Репозиторий для работы с журналом аудита."""
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get(self, audit_log_id: int) -> Optional[AuditLog]:
+        """Получение записи аудита по ID."""
+        return (
+            (
+                await self.db.execute(
+                    select(AuditLog).where(AuditLog.id == audit_log_id).limit(1)
+                )
+            )
+            .scalars()
+            .first()
+        )
+
+    async def get_all(
+        self,
+        limit: int | None = None,
+        offset: int | None = None,
+        user_id: int | None = None,
+        org_unit_id: int | None = None,
+        task_id: int | None = None,
+        form_id: int | None = None,
+        event_type: str | None = None,
+        date_from: datetime | None = None,
+        date_to: datetime | None = None,
+    ) -> tuple[Iterable[AuditLog], int]:
+        """Получение всех записей аудита с опциональной фильтрацией."""
+        query = select(AuditLog)
+        query_count = select(func.count(AuditLog.id))
+
+        if user_id is not None:
+            query = query.where(AuditLog.user_id == user_id)
+            query_count = query_count.where(AuditLog.user_id == user_id)
+        if org_unit_id is not None:
+            query = query.where(AuditLog.org_unit_id == org_unit_id)
+            query_count = query_count.where(AuditLog.org_unit_id == org_unit_id)
+        if task_id is not None:
+            query = query.where(AuditLog.task_id == task_id)
+            query_count = query_count.where(AuditLog.task_id == task_id)
+        if form_id is not None:
+            query = query.where(AuditLog.form_id == form_id)
+            query_count = query_count.where(AuditLog.form_id == form_id)
+        if event_type is not None:
+            query = query.where(AuditLog.event_type == event_type)
+            query_count = query_count.where(AuditLog.event_type == event_type)
+        if date_from is not None:
+            query = query.where(AuditLog.event_dt >= date_from)
+            query_count = query_count.where(AuditLog.event_dt >= date_from)
+        if date_to is not None:
+            query = query.where(AuditLog.event_dt <= date_to)
+            query_count = query_count.where(AuditLog.event_dt <= date_to)
+        
+        query = query.options(joinedload(AuditLog.user))
+
+        query = query.order_by(AuditLog.event_dt.desc())
+
+        if limit is not None:
+            query = query.limit(limit)
+        if offset is not None:
+            query = query.offset(offset)
+
+        return (await self.db.execute(query)).scalars().all(), (
+            await self.db.execute(query_count)
+        ).scalar_one()
+

api/src/repository/budget_form_repository.py

@@ -0,0 +1,85 @@
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.budget_form import BudgetForm
+from sqlalchemy.orm import joinedload
+
+
+
+class BudgetFormRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_list(
+            self, 
+            offset: int | None = None, 
+            limit: int | None = None,
+            org_unit: int | list[int] | None = None,
+            with_count: bool = False,
+            load_org: bool = False,
+    ) -> list[BudgetForm] | tuple[int, list[BudgetForm]]:
+        if with_count:
+            query = select(func.count().over().label("total_count"), BudgetForm)
+        else:
+            query = select(BudgetForm)
+        where = []
+        if org_unit is not None:
+            if isinstance(org_unit, int):
+                where.append(BudgetForm.org_unit_id == org_unit)
+            else:
+                where.append(BudgetForm.org_unit_id.in_(org_unit))
+
+        
+        query = query.where(*where)
+        if load_org:
+            query = query.options(
+                joinedload(BudgetForm.org_unit)
+            )
+        query = query.order_by(BudgetForm.id)
+
+        if offset is not None:
+            query = query.offset(offset)
+        if limit is not None:
+            query = query.limit(limit)
+
+        if with_count:
+            result = (await self.db.execute(query)).all()
+            if result:
+                return result[0][0], [res[1] for res in result]
+            else:
+                if query.whereclause is not None:
+                    count_query = select(func.count(BudgetForm.id)).where(
+                        query.whereclause
+                    )
+                    return (await self.db.execute(count_query)).scalar(), []
+        else:
+            return (await self.db.execute(query)).scalars().all()
+    
+    async def get(
+            self, 
+            budget_form_id: int,
+            org_unit: int | list[int] | None = None,
+            load_form_type: bool = False,
+            load_org: bool = False,
+    ) -> BudgetForm | None:
+        query = select(BudgetForm)
+    
+        where = [BudgetForm.id == budget_form_id]
+        if org_unit is not None:
+            if isinstance(org_unit, int):
+                where.append(BudgetForm.org_unit_id == org_unit)
+            else:
+                where.append(BudgetForm.org_unit_id.in_(org_unit))
+
+        query = query.where(*where)
+        if load_org:
+            query = query.options(
+                joinedload(BudgetForm.org_unit)
+            )
+
+        if load_form_type:
+            query = query.options(
+                joinedload(BudgetForm.form_type)
+            )
+        return (await self.db.execute(query)).scalars().first()
+    

api/src/repository/budget_line_repository.py

@@ -0,0 +1,26 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.budget_line import BudgetLine
+
+
+class BudgetLineRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get(self, budget_line_id: int) -> BudgetLine | None:
+        query = select(BudgetLine).where(BudgetLine.id == budget_line_id).limit(1)
+        return (await self.db.execute(query)).scalar_one_or_none()
+
+    async def get_list(self, budget_line_ids: list[int]) -> BudgetLine | None:
+        query = select(BudgetLine).where(BudgetLine.id.in_(budget_line_ids))
+        return (await self.db.execute(query)).scalars().all()
+
+    async def get_ids(
+            self,
+            budget_form_id: int,
+    ) -> list[int]:
+        
+        query = select(BudgetLine.id).where(BudgetLine.budget_form_id == budget_form_id)
+        return (await self.db.execute(query)).scalars().all()
+        

api/src/repository/form_phase_repository.py

@@ -0,0 +1,123 @@
+from datetime import datetime
+
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.form_phase import FormPhase
+
+
+class FormPhaseRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_list(
+            self,
+            budget_form_id: int,
+            sheet: str | None = None,
+            phase_code: str | None = None,
+    ) -> list[FormPhase]:
+        query = select(FormPhase).where(FormPhase.budget_form_id == budget_form_id)
+        if sheet is not None:
+            query = query.where(FormPhase.sheet == sheet)
+        if phase_code is not None:
+            query = query.where(FormPhase.phase_code == phase_code)
+        return (await self.db.execute(query)).scalars().all()
+
+    async def get(
+        self, budget_form_id: int, sheet: str, phase_code: str
+    ) -> FormPhase | None:
+        query = (
+            select(FormPhase)
+            .where(FormPhase.budget_form_id == budget_form_id)
+            .where(FormPhase.sheet == sheet)
+            .where(FormPhase.phase_code == phase_code)
+            .limit(1)
+        )
+        return (await self.db.execute(query)).scalar_one_or_none()
+
+    async def create(
+        self,
+        budget_form_id: int,
+        sheet: str,
+        phase_code: str,
+        role: str,
+        column_keys: list[str],
+        opens_at: datetime,
+        closes_at: datetime,
+    ) -> FormPhase:
+        result = await self.db.execute(
+            text(
+                """
+                SELECT
+                    (v3.add_form_phase(
+                        :budget_form_id,
+                        :sheet,
+                        :phase_code,
+                        :role,
+                        :column_keys,
+                        :opens_at,
+                        :closes_at
+                    )).budget_form_id
+                """
+            ),
+            {
+                "budget_form_id": budget_form_id,
+                "sheet": sheet,
+                "phase_code": phase_code,
+                "role": role,
+                "column_keys": column_keys,
+                "opens_at": opens_at,
+                "closes_at": closes_at,
+            },
+        )
+        if result.scalar_one_or_none() is None:
+            return None
+        return await self.get(budget_form_id, sheet, phase_code)
+
+    async def update(
+        self, budget_form_id: int, sheet: str, phase_code: str, data: dict
+    ) -> FormPhase | None:
+        result = await self.db.execute(
+            text(
+                """
+                SELECT
+                    (v3.upd_form_phase(
+                        :budget_form_id,
+                        :sheet,
+                        :phase_code,
+                        :role,
+                        :column_keys,
+                        :opens_at,
+                        :closes_at
+                    )).budget_form_id
+                """
+            ),
+            {
+                "budget_form_id": budget_form_id,
+                "sheet": sheet,
+                "phase_code": phase_code,
+                "role": data.get("role"),
+                "column_keys": data.get("column_keys"),
+                "opens_at": data.get("opens_at"),
+                "closes_at": data.get("closes_at"),
+            },
+        )
+        if result.scalar_one_or_none() is None:
+            return None
+        return await self.get(budget_form_id, sheet, phase_code)
+
+    async def delete(
+        self, budget_form_id: int, sheet: str, phase_code: str
+    ) -> bool:
+        result = await self.db.execute(
+            text(
+                "SELECT v3.del_form_phase(:budget_form_id, :sheet, :phase_code)"
+            ),
+            {
+                "budget_form_id": budget_form_id,
+                "sheet": sheet,
+                "phase_code": phase_code,
+            },
+        )
+        deleted = result.scalar_one_or_none()
+        return bool(deleted)

api/src/repository/org_unit_repository.py

@@ -0,0 +1,112 @@
+
+
+from sqlalchemy import func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.org_unit import OrgUnit
+
+from sqlalchemy.orm import joinedload
+
+
+
+
+class OrgUnitRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+    
+    async def get_list(
+            self, 
+            offset: int | None = None, 
+            limit: int | None = None,
+            is_ssp: bool | None = None,
+            is_active: bool | None = None,
+            with_count: bool = False,
+            load_users: bool = False,
+    ) -> list[OrgUnit] | tuple[int, list[OrgUnit]]:
+        if with_count:
+            query = select(func.count().over().label("total_count"), OrgUnit)
+        else:
+            query = select(OrgUnit)
+        where = []
+        if is_ssp is not None:
+            where.append(OrgUnit.is_ssp == is_ssp)
+        if is_active is not None:
+            where.append(OrgUnit.is_active == is_active)
+
+        
+        query = query.where(*where)
+        if load_users:
+            query = query.options(
+                joinedload(OrgUnit.users)
+            )
+        
+        query = query.order_by(OrgUnit.id)
+
+        if offset is not None:
+            query = query.offset(offset)
+        if limit is not None:
+            query = query.limit(limit)
+
+        if with_count:
+            result = (await self.db.execute(query)).unique().all()
+            if result:
+                return result[0][0], [res[1] for res in result]
+            else:
+                if query.whereclause is not None:
+                    count_query = select(func.count(OrgUnit.id)).where(
+                        query.whereclause
+                    )
+                    return (await self.db.execute(count_query)).scalar(), []
+        else:
+            return (await self.db.execute(query)).scalars().unique().all()
+            
+    
+    async def get(
+            self, 
+            org_unit_id: int,
+            load_users: bool = False
+    ) -> OrgUnit | None:
+        query = select(OrgUnit).where(OrgUnit.id == org_unit_id)
+        if load_users:
+            query = query.options(
+                joinedload(OrgUnit.users)
+            )
+
+        return (await self.db.execute(query)).scalars().first()
+
+    async def create(
+            self, 
+            title: str,
+            is_ssp: bool,
+        ) -> OrgUnit:
+        """Создание SSP."""
+        ssp = OrgUnit(title=title, is_ssp=is_ssp)
+        self.db.add(ssp)
+        await self.db.flush()
+        # await self.db.refresh(ssp)
+        return ssp
+
+    async def update(
+        self, org_unit: OrgUnit, **kwargs,
+    ) -> OrgUnit | None:
+        if not org_unit:
+            return None
+
+        for field, value in kwargs.items():
+            setattr(org_unit, field, value)
+        
+        await self.db.flush()
+        # await self.db.refresh(ssp)
+        return org_unit
+
+    async def logical_delete(self, org_unit_id: int, is_active: bool | None = None) -> bool:
+        """Логическое удаление SSP."""
+
+        query = update(OrgUnit).where(OrgUnit.id == org_unit_id)
+        if is_active is not None:
+            query = query.where(OrgUnit.is_active == is_active)
+        query = query.values(is_active=False)
+        res = await self.db.execute(query)
+        await self.db.flush()
+
+        return res.rowcount > 0

api/src/repository/project_repository.py

@@ -0,0 +1,354 @@
+import json
+
+from sqlalchemy import exists, false, func, select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.org_unit import OrgUnit
+from src.db.models.project import Project
+from src.db.models.rf_project_report import RfProjectReport
+from src.db.models.rf_project_report_line import RfProjectReportLine
+
+
+class ProjectRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    @staticmethod
+    def _serialize_project(project: Project, org_unit_name: str | None, report_count: int) -> dict:
+        return {
+            "id": project.id,
+            "name": project.name,
+            "level": project.level,
+            "parent_id": project.parent_id,
+            "project_type": project.project_type,
+            "vsp_format": project.vsp_format,
+            "placement_type": project.placement_type,
+            "object_address": project.object_address,
+            "staff_count": project.staff_count,
+            "total_area": float(project.total_area) if project.total_area is not None else None,
+            "org_unit_id": project.org_unit_id,
+            "org_unit_name": org_unit_name,
+            "report_count": int(report_count),
+        }
+
+    @staticmethod
+    def _apply_project_filters(query, year: int | None, branch_id: int | None, org_unit_ids: list[int] | None):
+        if year is not None:
+            query = query.where(
+                exists(
+                    select(1).where(
+                        RfProjectReport.project_id == Project.id,
+                        RfProjectReport.year == year,
+                    )
+                )
+            )
+        if branch_id is not None:
+            query = query.where(Project.org_unit_id == branch_id)
+        if org_unit_ids is not None:
+            if len(org_unit_ids) == 0:
+                query = query.where(false())
+            else:
+                query = query.where(Project.org_unit_id.in_(org_unit_ids))
+        return query
+
+    async def get_list(
+        self,
+        year: int | None = None,
+        branch_id: int | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+        with_count: bool = False,
+        org_unit_ids: list[int] | None = None,
+    ) -> list[dict] | tuple[int, list[dict]]:
+        report_count_subq = (
+            select(func.count(RfProjectReport.id))
+            .where(RfProjectReport.project_id == Project.id)
+            .scalar_subquery()
+        )
+
+        query = (
+            select(
+                Project,
+                OrgUnit.title.label("org_unit_name"),
+                report_count_subq.label("report_count"),
+            )
+            .outerjoin(OrgUnit, OrgUnit.id == Project.org_unit_id)
+            .order_by(Project.id)
+        )
+        query = self._apply_project_filters(query, year, branch_id, org_unit_ids)
+        if offset is not None:
+            query = query.offset(offset)
+        if limit is not None:
+            query = query.limit(limit)
+
+        rows = (await self.db.execute(query)).all()
+        payload = [self._serialize_project(row[0], row[1], row[2]) for row in rows]
+        if not with_count:
+            return payload
+
+        count_query = select(func.count(Project.id))
+        count_query = self._apply_project_filters(count_query, year, branch_id, org_unit_ids)
+        total = int((await self.db.execute(count_query)).scalar() or 0)
+        return total, payload
+
+    async def get(
+        self,
+        project_id: int,
+        org_unit_ids: list[int] | None = None,
+    ) -> dict | None:
+        report_count_subq = (
+            select(func.count(RfProjectReport.id))
+            .where(RfProjectReport.project_id == Project.id)
+            .scalar_subquery()
+        )
+        query = (
+            select(
+                Project,
+                OrgUnit.title.label("org_unit_name"),
+                report_count_subq.label("report_count"),
+            )
+            .outerjoin(OrgUnit, OrgUnit.id == Project.org_unit_id)
+            .where(Project.id == project_id)
+        )
+        if org_unit_ids is not None:
+            if len(org_unit_ids) == 0:
+                return None
+            query = query.where(Project.org_unit_id.in_(org_unit_ids))
+        row = (await self.db.execute(query)).first()
+        if not row:
+            return None
+        return self._serialize_project(row[0], row[1], row[2])
+
+    async def get_reports(self, project_id: int) -> list[dict]:
+        line_count_subq = (
+            select(func.count(RfProjectReportLine.id))
+            .where(RfProjectReportLine.rf_project_report_id == RfProjectReport.id)
+            .scalar_subquery()
+        )
+        query = (
+            select(
+                RfProjectReport.id,
+                RfProjectReport.year,
+                RfProjectReport.report_type,
+                RfProjectReport.created_by,
+                RfProjectReport.created_at,
+                RfProjectReport.updated_by,
+                RfProjectReport.updated_at,
+                line_count_subq.label("line_count"),
+            )
+            .where(RfProjectReport.project_id == project_id)
+            .order_by(RfProjectReport.year, RfProjectReport.report_type)
+        )
+        rows = (await self.db.execute(query)).all()
+        reports: list[dict] = []
+        for row in rows:
+            reports.append(
+                {
+                    "id": row[0],
+                    "year": row[1],
+                    "report_type": row[2],
+                    "created_by": row[3],
+                    "created_at": row[4].isoformat() if row[4] is not None else None,
+                    "updated_by": row[5],
+                    "updated_at": row[6].isoformat() if row[6] is not None else None,
+                    "line_count": int(row[7]),
+                }
+            )
+        return reports
+
+    async def resolve_report_id(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        org_unit_ids: list[int] | None = None,
+    ) -> int | None:
+        query = (
+            select(RfProjectReport.id)
+            .join(Project, Project.id == RfProjectReport.project_id)
+            .where(
+                Project.id == project_id,
+                RfProjectReport.year == year,
+                RfProjectReport.report_type == report_type,
+            )
+        )
+        if org_unit_ids is not None:
+            if len(org_unit_ids) == 0:
+                return None
+            query = query.where(Project.org_unit_id.in_(org_unit_ids))
+        return (await self.db.execute(query)).scalar_one_or_none()
+
+    async def get_report_rows(self, report_id: int, sections: list[str] | None = None) -> list[tuple]:
+        query = text(
+            """
+            SELECT row_type, depth, sort_order, data
+            FROM v3.v_form3_report_jsonb(CAST(:report_id AS INT), CAST(:sections AS TEXT[]))
+            """
+        )
+        return (await self.db.execute(query, {"report_id": report_id, "sections": sections})).all()
+
+    async def get_rf_rollup_rows(
+        self,
+        branch_id: int,
+        year: int,
+        sections: list[str] | None = None,
+    ) -> list[tuple]:
+        query = text(
+            """
+            SELECT row_type, depth, sort_order, data
+            FROM v3.v_form3_rf_rollup_jsonb(CAST(:branch_id AS INT), CAST(:year AS INT), CAST(:sections AS TEXT[]))
+            """
+        )
+        return (
+            await self.db.execute(
+                query,
+                {"branch_id": branch_id, "year": year, "sections": sections},
+            )
+        ).all()
+
+    async def upd_form3_cell(
+        self,
+        report_id: int,
+        line_id: int,
+        column: str,
+        value,
+    ) -> list[tuple]:
+        query = text(
+            """
+            SELECT row_type, depth, sort_order, data
+            FROM v3.upd_form3_cell(
+                CAST(:report_id AS INT),
+                CAST(:line_id AS INT),
+                CAST(:column AS TEXT),
+                CAST(:value AS JSONB)
+            )
+            """
+        )
+        rows = (
+            await self.db.execute(
+                query,
+                {
+                    "report_id": report_id,
+                    "line_id": line_id,
+                    "column": column,
+                    "value": json.dumps(value),
+                },
+            )
+        ).all()
+        return [tuple(r) for r in rows]
+
+    async def upd_form3_cells(self, report_id: int, changes: list[dict]) -> list[tuple]:
+        query = text(
+            """
+            SELECT row_type, depth, sort_order, data
+            FROM v3.upd_form3_cells(CAST(:report_id AS INT), CAST(:changes AS JSONB))
+            """
+        )
+        rows = (
+            await self.db.execute(
+                query,
+                {
+                    "report_id": report_id,
+                    "changes": json.dumps(changes),
+                },
+            )
+        ).all()
+        return [tuple(r) for r in rows]
+
+    async def add_form3_line(self, report_id: int, expense_item_id: int) -> list[tuple]:
+        query = text(
+            """
+            SELECT row_type, depth, sort_order, data
+            FROM v3.add_form3_line(CAST(:report_id AS INT), CAST(:expense_item_id AS INT))
+            """
+        )
+        rows = (
+            await self.db.execute(
+                query,
+                {
+                    "report_id": report_id,
+                    "expense_item_id": expense_item_id,
+                },
+            )
+        ).all()
+        return [tuple(r) for r in rows]
+
+    async def del_form3_line(self, line_id: int) -> list[tuple]:
+        query = text(
+            """
+            SELECT row_type, depth, sort_order, data
+            FROM v3.del_form3_line(CAST(:line_id AS INT))
+            """
+        )
+        rows = (await self.db.execute(query, {"line_id": line_id})).all()
+        return [tuple(r) for r in rows]
+
+    async def upd_project(self, project_id: int, column: str, value):
+        query = text(
+            """
+            SELECT v3.upd_project(CAST(:project_id AS INT), CAST(:column AS TEXT), CAST(:value AS JSONB))
+            """
+        )
+        result = (
+            await self.db.execute(
+                query,
+                {
+                    "project_id": project_id,
+                    "column": column,
+                    "value": json.dumps(value),
+                },
+            )
+        ).scalar_one()
+        return result
+
+    async def add_project(
+        self,
+        name: str,
+        year: int,
+        org_unit_id: int,
+        level: str = "project",
+        parent_id: int | None = None,
+        project_type: str | None = None,
+        vsp_format: str | None = None,
+        placement_type: str | None = None,
+        object_address: str | None = None,
+        staff_count: int | None = None,
+        total_area: float | None = None,
+    ) -> tuple[int, int, int]:
+        query = text(
+            """
+            SELECT project_id, limit_report_id, current_expenses_report_id
+            FROM v3.add_project(
+                CAST(:name AS VARCHAR),
+                CAST(:year AS INT),
+                CAST(:org_unit_id AS INT),
+                CAST(:level AS VARCHAR),
+                CAST(:parent_id AS INT),
+                CAST(:project_type AS VARCHAR),
+                CAST(:vsp_format AS VARCHAR),
+                CAST(:placement_type AS VARCHAR),
+                CAST(:object_address AS VARCHAR),
+                CAST(:staff_count AS INT),
+                CAST(:total_area AS NUMERIC)
+            )
+            """
+        )
+        row = (
+            await self.db.execute(
+                query,
+                {
+                    "name": name,
+                    "year": year,
+                    "org_unit_id": org_unit_id,
+                    "level": level,
+                    "parent_id": parent_id,
+                    "project_type": project_type,
+                    "vsp_format": vsp_format,
+                    "placement_type": placement_type,
+                    "object_address": object_address,
+                    "staff_count": staff_count,
+                    "total_area": total_area,
+                },
+            )
+        ).first()
+        return int(row[0]), int(row[1]), int(row[2])

api/src/repository/sheet_repository.py

@@ -0,0 +1,245 @@
+import enum
+import itertools
+import json
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.form_type import FormType
+
+
+class DirectionEnum(str, enum.Enum):
+    SUPPORT = "Support"
+    DEVELOPMENT = "Development"
+
+ACCEPTABLE_SHEETS = set(itertools.chain(*FormType.SHEETS_BY_FORM_TYPE.values()))
+ACCEPTABLE_SECTIONS = set(itertools.chain(*FormType.SECTIONS_BY_FORM_TYPE.values()))
+
+
+
+class SheetValidationError(Exception):
+
+    def __init__(self, message, *args):
+        super().__init__(*args)
+        self.message = message
+
+
+class SheetRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get(
+            self, 
+            form_id: int, 
+            sheet: str, 
+            direction: str | None,
+            sections: list[str] | None = None,
+    ) -> list[tuple]:
+        if any(
+            [
+                not isinstance(form_id, int),
+                sheet not in ACCEPTABLE_SHEETS,
+                direction is not None and direction not in [s.value for s in DirectionEnum],
+                sections and (set(sections) - ACCEPTABLE_SECTIONS),
+            ]
+        ):
+            raise SheetValidationError("Некорректные данные")
+
+
+        if direction:
+            func_query = "v3.v_form_view(:form_id, :sheet, :sections, :direction)"
+        else:
+            func_query = "v3.v_form_view(:form_id, :sheet, :sections)"
+        
+        return (
+            await self.db.execute(
+                text(
+                    f"""
+                        SELECT row_type, depth, sort_order, data 
+                        FROM {func_query}
+                    """
+                ),
+                {
+                    "form_id": form_id,
+                    "sheet": sheet,
+                    "direction": direction,
+                    "sections": sections,
+                }
+            )
+        ).all()
+    
+    async def update_cell(
+            self, 
+            form_id: int, 
+            sheet: str,
+            direction: str | None,
+            sections: list[str] | None,
+            line_id: int, 
+            column: str, 
+            value: str | int | float | None = None, 
+            user_id: int = None,
+    ) -> list[tuple]:
+        if any(
+            [
+                not isinstance(form_id, int),
+                sheet not in ACCEPTABLE_SHEETS,
+                direction is not None and direction not in [s.value for s in DirectionEnum],
+                sections and (set(sections) - ACCEPTABLE_SECTIONS),
+            ]
+        ):
+            raise SheetValidationError("Некорректные данные")
+        if user_id:
+            func_query = "v3.upd_form_cell(:form_id, :sheet, :line_id, :column, :value, :user_id, :direction, :sections)"
+        else:
+            func_query = "v3.upd_form_cell(:form_id, :sheet, :line_id, :column, :value, :direction, :sections)"
+
+        return [
+            tuple(r) for r in (
+                await self.db.execute(
+                    text(
+                        f"""
+                            SELECT row_type, depth, sort_order, data 
+                            FROM {func_query}
+                        """
+                    ),
+                    {
+                        "form_id": form_id, 
+                        "sheet": sheet,
+                        "direction": direction,
+                        "sections": sections,
+                        "line_id": line_id, 
+                        "column": column, 
+                        "value": json.dumps(value), 
+                        "user_id": user_id,
+                    }
+                )
+            ).all()
+        ]
+
+    async def update_cells(
+            self, 
+            form_id: int, 
+            sheet: str,
+            direction: str | None,
+            sections: list[str] | None,
+            changes: list[dict],
+            user_id: int = None,
+    ) -> list[tuple]:
+        if any(
+            [
+                not isinstance(form_id, int),
+                sheet not in ACCEPTABLE_SHEETS,
+                direction is not None and direction not in [s.value for s in DirectionEnum],
+                sections and (set(sections) - ACCEPTABLE_SECTIONS),
+            ]
+        ):
+            raise SheetValidationError("Некорректные данные")
+        changes = json.dumps(changes)
+        if user_id:
+            func_query = "v3.upd_form_cells(:form_id, :sheet, :changes, :user_id, :direction, :sections)"
+        else:
+            func_query = "v3.upd_form_cells(:form_id, :sheet, :changes, :direction, :sections)"
+
+        return [
+            tuple(r) for r in (
+                await self.db.execute(
+                    text(
+                        f"""
+                            SELECT row_type, depth, sort_order, data 
+                            FROM {func_query}
+                        """
+                    ),
+                    {
+                        "form_id": form_id, 
+                        "sheet": sheet,
+                        "direction": direction,
+                        "sections": sections,
+                        "changes": changes,
+                        "user_id": user_id,
+                    }
+                )
+            ).all()
+        ]
+
+    async def add_line(
+            self,
+            form_id: int,
+            sheet: str,
+            expense_item_id: int | None = None,
+            item_id: str | None = None,
+            section_code: str | None = None,
+            direction: str | None = None,
+            name: str | None = None,
+            internal_order: str | None = None,
+            vsp_id: int | None = None,
+            project_id: int | None = None,
+            justification: str | None = None,
+            contract_number: str | None = None,
+            contract_end_date: str | None = None,
+            user_id: int | None = None,
+    ) -> list[tuple]:
+        return [
+            tuple(r) for r in (
+                await self.db.execute(
+                    text(
+                        """
+                        SELECT row_type, depth, sort_order, data
+                        FROM v3.add_budget_line(
+                        :p_form_id,
+                        :p_expense_item_id,
+                        :p_sheet,
+                        :p_item_id,
+                        :p_section_code,
+                        :p_direction,
+                        :p_name,
+                        :p_internal_order,
+                        :p_vsp_id,
+                        :p_project_id,
+                        :p_justification,
+                        :p_contract_number,
+                        :p_contract_end_date
+                        )
+                        """
+                    ),
+                    {
+                        "p_form_id": form_id,
+                        "p_expense_item_id": expense_item_id,
+                        "p_sheet": sheet,
+                        "p_item_id": item_id,
+                        "p_section_code": section_code,
+                        "p_direction": direction,
+                        "p_name": name,
+                        "p_internal_order": internal_order,
+                        "p_vsp_id": vsp_id,
+                        "p_project_id": project_id,
+                        "p_justification": justification,
+                        "p_contract_number": contract_number,
+                        "p_contract_end_date": contract_end_date,
+                    }
+                )
+            ).all()
+        ]
+
+    async def delete_line(
+            self,
+            sheet: str,
+            row_id: int,
+            direction: str | None = None,
+    ) -> list[tuple]:
+
+        return [
+            tuple(r) for r in (
+                await self.db.execute(
+                    text(
+                        "SELECT row_type, depth, sort_order, data "
+                        "FROM v3.del_budget_line(:p_row_id, :p_direction, :p_sheet)"
+                    ),
+                    {
+                        "p_row_id": row_id,
+                        "p_direction": direction,
+                        "p_sheet": sheet,
+                    }
+                )
+            ).all()
+        ]
+

api/src/repository/user_repository.py

@@ -1,96 +1,119 @@
 from typing import Optional
 
-from sqlalchemy import delete, select, update
+from sqlalchemy import delete, func, select, text, update
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import joinedload, selectinload
 
+
+from src.db.models.org_unit import OrgUnit
+from src.db.models.role import Role
+from src.db.models.user_org import UserOrg
+from src.db.models.app_user import AppUser
 from src.core.security import get_password_hash, verify_password
-from src.domain.models import Roles, SSP, UserSSPLink, Users
+
 
 
 class UserRepository:
     def __init__(self, db: AsyncSession):
         self.db = db
 
-    async def get(self, user_id: int) -> Optional[Users]:
+    async def get(self, user_id: int, load_orgs: bool = False) -> Optional[AppUser]:
+        query = select(AppUser).where(AppUser.id == user_id)
+        if load_orgs:
+            query = query.options(
+                selectinload(AppUser.org_units),
+            )
+
         return (
             (
                 await self.db.execute(
-                    select(Users).where(Users.id == user_id).limit(1)
+                    query.limit(1)
                 )
             )
             .scalars()
             .first()
         )
 
-    async def get_by_email(self, email: str) -> Optional[Users]:
+    async def get_by_email(self, email: str) -> Optional[AppUser]:
         return (
             (
                 await self.db.execute(
-                    select(Users).where(Users.email == email).limit(1)
+                    select(AppUser).where(AppUser.email == email).limit(1)
                 )
             )
             .scalars()
             .first()
         )
 
-    async def get_by_username(self, username: str) -> Optional[Users]:
+    async def get_by_username(self, username: str) -> Optional[AppUser]:
         return (
             (
                 await self.db.execute(
-                    select(Users).where(Users.username == username).limit(1)
+                    select(AppUser).where(AppUser.username == username).limit(1)
                 )
             )
             .scalars()
             .first()
         )
 
-    async def get_list(self, skip: int = 0, limit: int = 100) -> list[Users]:
-        query = (
-            select(Users)
-            .where(Users.is_active.is_(True))
-            .offset(skip)
-            .limit(limit)
-            .order_by(Users.id)
+    async def set_app_user_id(self, user_id: int) -> None:
+        if isinstance(user_id, int):
+            await self.db.execute(
+                text(
+                    f"SET LOCAL app.user_id = {user_id}"
+                ),
             )
-        return (await self.db.execute(query)).scalars().all()
             
-    async def create(self, user_data: dict) -> Users:
-        hashed_password = (
-            get_password_hash(user_data["password"]) if user_data.get("password") else None
+
+    async def get_list(
+            self, 
+            skip: int = 0, 
+            limit: int = 100,
+            with_count: bool = False,
+            load_orgs: bool = False,
+    ) -> list[AppUser] | tuple[int, list[AppUser]]:
+        
+        where = [AppUser.is_active.is_(True)]
+        
+        if with_count:
+            query = select(func.count().over().label("total_count"), AppUser)
+        else:
+            query = select(AppUser)
+
+        
+        query = query.where(*where)
+        if load_orgs:
+            query = query.options(
+                joinedload(AppUser.org_units)
             )
-        db_user = Users(
-            email=user_data["email"],
-            username=user_data["username"],
-            hashed_password=hashed_password,
-            full_name=user_data.get("full_name"),
-            role_id=user_data.get("role_id"),
+        
+        query = query.order_by(AppUser.id)
+
+        if skip is not None:
+            query = query.offset(skip)
+        if limit is not None:
+            query = query.limit(limit)
+
+        if with_count:
+            result = (await self.db.execute(query)).unique().all()
+            if result:
+                return result[0][0], [res[1] for res in result]
+            else:
+                if query.whereclause is not None:
+                    count_query = select(func.count(AppUser.id)).where(
+                        query.whereclause
                     )
-        self.db.add(db_user)
-        await self.db.commit()
-        await self.db.refresh(db_user)
-        return db_user
-
-    async def update(self, user_id: int, user_data: dict) -> Optional[Users]:
-        user = await self.get(user_id)
-        if not user:
-            return None
-
-        for field, value in user_data.items():
-            if field == "password" and value:
-                value = get_password_hash(value)
-            setattr(user, field, value)
-
-        await self.db.commit()
-        await self.db.refresh(user)
-        return user
+                    return (await self.db.execute(count_query)).scalar(), []
+        else:
+            return (await self.db.execute(query)).scalars().unique().all()
 
     async def logical_delete(self, user_id: int) -> bool:
-        query = update(Users).where(Users.id == user_id).values(is_active=False)
+        query = update(AppUser).where(AppUser.id == user_id).values(is_active=False)
         result = await self.db.execute(query)
         await self.db.commit()
         return result.rowcount > 0
 
-    async def authenticate(self, username: str, password: str) -> Optional[Users]:
+    async def authenticate(self, username: str, password: str) -> Optional[AppUser]:
         user = await self.get_by_username(username)
         if not user:
             return None
@@ -98,52 +121,122 @@ class UserRepository:
             return None
         return user
 
-    async def authenticate_via_email(self, email: str) -> Optional[Users]:
+    async def authenticate_via_email(self, email: str) -> Optional[AppUser]:
         return await self.get_by_email(email)
 
-    async def get_roles(self) -> list[Roles]:
-        return (await self.db.execute(select(Roles).order_by(Roles.id))).scalars().all()
+    async def get_roles(self) -> list[Role]:
+        return (await self.db.execute(select(Role).order_by(Role.id))).scalars().all()
 
-    async def get_many_ssp(self, user_id: int) -> list[SSP]:
-        query = select(SSP).join(UserSSPLink, UserSSPLink.ssp_id == SSP.id).where(
-            UserSSPLink.user_id == user_id
+    async def get_many_ssp(self, user_id: int) -> list[OrgUnit]:
+        query = select(OrgUnit).join(UserOrg, UserOrg.org_unit_id == OrgUnit.id).where(
+            UserOrg.user_id == user_id
         )
         return (await self.db.execute(query)).scalars().all()
 
     async def get_many_ssp_ids(self, user_id: int) -> list[int]:
-        query = select(UserSSPLink.ssp_id).where(UserSSPLink.user_id == user_id)
+        query = select(UserOrg.org_unit_id).where(UserOrg.user_id == user_id)
         return (await self.db.execute(query)).scalars().all()
 
     async def set_many_ssp(self, user_id: int, ssp_ids: list[int]) -> bool:
-        try:
         for ssp_id in ssp_ids:
-                link = UserSSPLink(user_id=user_id, ssp_id=ssp_id)
-                self.db.add(link)
+            await self.db.execute(
+                text(
+                    "SELECT v3.grant_user_org_access(:user_id, :org_unit_id)"
+                ),
+                {"user_id": user_id, "org_unit_id": ssp_id},
+            )
         await self.db.commit()
         return True
-        except Exception:
-            await self.db.rollback()
-            return False
 
     async def unset_many_ssp(self, user_id: int, ssp_ids: list[int]) -> bool:
-        try:
         for ssp_id in ssp_ids:
-                query = delete(UserSSPLink).where(
-                    (UserSSPLink.user_id == user_id) & (UserSSPLink.ssp_id == ssp_id)
+            await self.db.execute(
+                text(
+                    "SELECT v3.revoke_user_org_access(:user_id, :org_unit_id)"
+                ),
+                {"user_id": user_id, "org_unit_id": ssp_id},
             )
-                await self.db.execute(query)
         await self.db.commit()
         return True
-        except Exception:
-            await self.db.rollback()
-            return False
 
-    async def clear_many_ssp(self, user_id: int) -> bool:
-        try:
-            query = delete(UserSSPLink).where(UserSSPLink.user_id == user_id)
-            await self.db.execute(query)
+    async def clear_many_ssp(self, user_id: int) -> None:
+        org_unit_ids = await self.get_many_ssp_ids(user_id)
+        await self.db.execute(
+            text(
+                "SELECT v3.revoke_many_user_org_access(:user_id, :org_unit_ids)"
+            ),
+            {"user_id": user_id, "org_unit_ids": org_unit_ids},
+        )
         await self.db.commit()
-            return True
-        except Exception:
-            await self.db.rollback()
-            return False
+
+    async def create(self, user_data: dict) -> AppUser:
+        hashed_password = (
+            get_password_hash(user_data["password"]) if user_data.get("password") else None
+        )
+        user_id = (
+            await self.db.execute(
+                text(
+                    """
+                    SELECT (v3.add_user(
+                        :email,
+                        :username,
+                        :hashed_password,
+                        :full_name,
+                        :role_id
+                    )).id
+                    """
+                ),
+                {
+                    "email": user_data["email"],
+                    "username": user_data["username"],
+                    "hashed_password": hashed_password,
+                    "full_name": user_data.get("full_name"),
+                    "role_id": user_data.get("role_id"),
+                },
+            )
+        ).scalar_one()
+        await self.db.flush()
+        return await self.get(user_id)
+
+    async def update(
+            self, 
+            user_id: int, 
+            user_data: dict,
+            load_orgs: bool = False,
+    ) -> Optional[AppUser]:
+        user = await self.get(user_id)
+        if not user:
+            return None
+
+        hashed_password = None
+        if "password" in user_data and user_data["password"]:
+            hashed_password = get_password_hash(user_data["password"])
+
+        await self.db.execute(
+            text(
+                """
+                SELECT (v3.upd_user(
+                    :user_id,
+                    :email,
+                    :username,
+                    :hashed_password,
+                    :full_name,
+                    :role_id,
+                    :is_active
+                )).id
+                """
+            ),
+            {
+                "user_id": user_id,
+                "email": user_data.get("email"),
+                "username": user_data.get("username"),
+                "hashed_password": hashed_password,
+                "full_name": user_data.get("full_name"),
+                "role_id": user_data.get("role_id"),
+                "is_active": user_data.get("is_active"),
+            },
+        )
+        await self.db.flush()
+        self.db.expire(user)
+        result = await self.get(user_id, load_orgs=load_orgs)
+        return result

api/src/services/access_control_service.py

@@ -0,0 +1,46 @@
+import enum
+import typing
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.app_user import AppUser
+from src.db.models.budget_form import BudgetForm
+from src.db.models.role import UserRoleEnum
+from src.repository.user_repository import UserRepository
+
+
+class AccessEnum(int, enum.Enum):
+    RESTRICT = 0
+    VIEW = 1
+    EDIT = 2
+
+
+class AccessControlService:
+    def __init__(self, db: AsyncSession, user: AppUser):
+        self.db = db
+        self.user_repo = UserRepository(db)
+    
+    async def _check_budget_form(
+            self,
+            user: AppUser,
+            budget_form: BudgetForm,
+    ) -> AccessEnum:
+        if user.role_id == UserRoleEnum.ADMIN:
+            return AccessEnum.EDIT
+        user = await self.user_repo.get(
+            user_id=user.id,
+            load_orgs=True,
+        )
+        if budget_form.org_unit_id in [ou.id for ou in user.org_units]:
+            return AccessEnum.EDIT
+        return AccessEnum.RESTRICT
+    
+    async def check_object_access(
+            self,
+            user: AppUser,
+            object: typing.Any
+    ) -> AccessEnum:
+        if isinstance(object, BudgetForm):
+            return await self._check_budget_form(user=user,budget_form=object)
+        return AccessEnum.EDIT
+

api/src/services/auditlog_service.py

@@ -0,0 +1,96 @@
+from datetime import datetime
+from typing import Any, Dict, Iterable, Optional
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.core.errors import AccessDeniedException
+
+# from src.domain.models import AuditLog, UserRole, Users
+from src.db.models.audit_log import AuditLog
+from src.db.models.role import UserRoleEnum
+from src.db.models.app_user import AppUser
+
+from src.repository.auditlog_repository import AuditLogRepository
+
+from src.domain.schemas import AuditLog as AuditLogSchema
+
+
+class AuditLogService:
+    """Сервис для работы с журналом аудита."""
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+        self.audit_repo = AuditLogRepository(db)
+
+    async def get(self, audit_log_id: int, user: AppUser) -> Optional[AuditLog]:
+        """Получение записи аудита по ID."""
+        if not self._can_view_audit_logs(user):
+            raise AccessDeniedException(
+                "Недостаточно прав для просмотра журнала аудита"
+            )
+
+        return await self.audit_repo.get(audit_log_id)
+
+    async def get_all(
+        self,
+        user: AppUser,
+        limit: int | None = None,
+        offset: int | None = None,
+        user_id: int | None = None,
+        org_unit_id: int | None = None,
+        task_id: int | None = None,
+        form_id: int | None = None,
+        event_type: str | None = None,
+        date_from: datetime | None = None,
+        date_to: datetime | None = None,
+    ) -> tuple[Iterable[AuditLog], int]:
+        """Получение всех записей аудита с опциональной фильтрацией."""
+        if not self._can_view_audit_logs(user):
+            raise AccessDeniedException(
+                "Недостаточно прав для просмотра журнала аудита"
+            )
+
+        return await self.audit_repo.get_all(
+            limit=limit,
+            offset=offset,
+            user_id=user_id,
+            org_unit_id=org_unit_id,
+            task_id=task_id,
+            form_id=form_id,
+            event_type=event_type,
+            date_from=date_from,
+            date_to=date_to,
+        )
+
+    def _can_view_audit_logs(self, user: AppUser) -> bool:
+        """Проверяет, может ли пользователь просматривать журнал аудита."""
+        return user.role_id == UserRoleEnum.ADMIN.value
+
+    def orm_log_to_response(self, log: AuditLog) -> AuditLogSchema:
+        """Маппинг записи ORM audit_log в формат ответа API (entity, entity_id, action, at, payload_json).
+        model_validate(orm) не подходит: в БД поля event_dt/event/event_type/event_data, в API — at/action/entity/entity_id; entity и entity_id из event_data JSON.
+        """
+        event_data: Optional[Dict[str, Any]] = getattr(log, "event_data", None) or {}
+        entity = (
+            event_data.get("entity_type") if isinstance(event_data, dict) else None
+        ) or getattr(log, "event_type", "unknown")
+        entity_id = (
+            event_data.get("entity_id") if isinstance(event_data, dict) else None
+        )
+        if entity_id is not None and not isinstance(entity_id, int):
+            try:
+                entity_id = int(entity_id)
+            except (TypeError, ValueError):
+                entity_id = None
+        action = getattr(log, "event", "")
+        at = getattr(log, "event_dt", None)
+        return AuditLogSchema(
+            entity=entity,
+            entity_id=entity_id,
+            action=action,
+            payload_json=event_data if isinstance(event_data, dict) else None,
+            id=log.id,
+            user_id=getattr(log, "user_id", None),
+            at=at,
+            user=getattr(log, "user", None),
+        )

api/src/services/budget_form_service.py

@@ -0,0 +1,67 @@
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.repository.user_repository import UserRepository
+from src.db.models.app_user import AppUser
+from src.db.models.budget_form import BudgetForm
+from src.db.models.role import UserRoleEnum
+from src.repository.budget_form_repository import BudgetFormRepository
+
+
+
+class BudgetFormService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+        self.bf_repo = BudgetFormRepository(db)
+        self.user_repo = UserRepository(db)
+
+    async def get_list(
+            self,
+            user: AppUser,
+            offset: int | None = None,
+            limit: int | None = None,
+            with_count: bool = False,
+            load_org: bool = False,
+    ) -> list[BudgetForm] | tuple[int, list[BudgetForm]]:
+        if user.role_id == UserRoleEnum.ADMIN:
+            return await self.bf_repo.get_list(
+                offset=offset,
+                limit=limit,
+                with_count=with_count,
+                load_org=load_org,
+            )
+        user = await self.user_repo.get(
+            user_id=user.id,
+            load_orgs=True,
+        )
+        return await self.bf_repo.get_list(
+            offset=offset,
+            limit=limit,
+            org_unit=[ou.id for ou in user.org_units],
+            with_count=with_count,
+            load_org=load_org,
+        )
+
+    async def get(
+            self,
+            budget_form_id: int,
+            user: AppUser,
+            load_form_type: bool = False,
+            load_org: bool = False,
+    ) -> BudgetForm | None:
+        if user.role_id == UserRoleEnum.ADMIN:
+            return await self.bf_repo.get(
+                budget_form_id=budget_form_id,
+                load_form_type=load_form_type,
+                load_org=load_org,
+            )
+        user = await self.user_repo.get(
+            user_id=user.id,
+            load_orgs=True,
+        )
+        return await self.bf_repo.get(
+            budget_form_id=budget_form_id,
+            org_unit=[ou.id for ou in user.org_units],
+            load_form_type=load_form_type,
+            load_org=load_org,
+        )

api/src/services/budget_line_service.py

@@ -0,0 +1,35 @@
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.app_user import AppUser
+from src.db.models.budget_line import BudgetLine
+from src.repository.budget_line_repository import BudgetLineRepository
+
+
+
+
+class BudgetLineService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+        self.bl_repo = BudgetLineRepository(db)
+
+    async def get(
+            self, 
+            user: AppUser, 
+            budget_line_id: int,
+    ) -> BudgetLine | None:
+        return await self.bl_repo.get(budget_line_id=budget_line_id)
+
+    async def get_list(
+            self, 
+            user: AppUser, 
+            budget_line_ids: list[int],
+    ) -> list[BudgetLine]:
+        return await self.bl_repo.get_list(budget_line_ids=budget_line_ids)
+
+    async def get_ids(
+            self,
+            budget_form_id: int,
+    ) -> list[int]:
+        return await self.bl_repo.get_ids(budget_form_id=budget_form_id)
+        

api/src/services/export_normalizers.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+SMETA_VALUE_PATHS: list[tuple[str, tuple[str, ...]]] = [
+    ("section_code", ("section_code",)),
+    ("name", ("name",)),
+    ("plan_support_q1", ("plan", "support", "q1")),
+    ("plan_support_q2", ("plan", "support", "q2")),
+    ("plan_support_q3", ("plan", "support", "q3")),
+    ("plan_support_q4", ("plan", "support", "q4")),
+    ("plan_support_year", ("plan", "support", "year")),
+    ("plan_development_q1", ("plan", "development", "q1")),
+    ("plan_development_q2", ("plan", "development", "q2")),
+    ("plan_development_q3", ("plan", "development", "q3")),
+    ("plan_development_q4", ("plan", "development", "q4")),
+    ("plan_development_year", ("plan", "development", "year")),
+    ("plan_total_year", ("plan", "total_year")),
+    ("approved_support_q1", ("approved", "support", "q1")),
+    ("approved_support_q2", ("approved", "support", "q2")),
+    ("approved_support_q3", ("approved", "support", "q3")),
+    ("approved_support_q4", ("approved", "support", "q4")),
+    ("approved_support_year", ("approved", "support", "year")),
+    ("approved_development_q1", ("approved", "development", "q1")),
+    ("approved_development_q2", ("approved", "development", "q2")),
+    ("approved_development_q3", ("approved", "development", "q3")),
+    ("approved_development_q4", ("approved", "development", "q4")),
+    ("approved_development_year", ("approved", "development", "year")),
+    ("approved_total_year", ("approved", "total_year")),
+    ("fact_support_q1", ("fact", "support", "q1")),
+    ("fact_support_q2", ("fact", "support", "q2")),
+    ("fact_support_q3", ("fact", "support", "q3")),
+    ("fact_support_q4", ("fact", "support", "q4")),
+    ("fact_support_year", ("fact", "support", "year")),
+    ("fact_development_q1", ("fact", "development", "q1")),
+    ("fact_development_q2", ("fact", "development", "q2")),
+    ("fact_development_q3", ("fact", "development", "q3")),
+    ("fact_development_q4", ("fact", "development", "q4")),
+    ("fact_development_year", ("fact", "development", "year")),
+    ("fact_total_year", ("fact", "total_year")),
+    ("corrected_support_q2", ("corrected", "support", "q2")),
+    ("corrected_support_q3", ("corrected", "support", "q3")),
+    ("corrected_support_q4", ("corrected", "support", "q4")),
+    ("corrected_development_q2", ("corrected", "development", "q2")),
+    ("corrected_development_q3", ("corrected", "development", "q3")),
+    ("corrected_development_q4", ("corrected", "development", "q4")),
+]
+QUARTER_KEYS = ("q1", "q2", "q3", "q4", "totals")
+FORM1_SECTION_BLOCK_KEYS = (
+    "sequestration",
+    "allocation",
+    "reserve",
+    "approved",
+    "collegial",
+    "ckk",
+    "contract",
+    "plan",
+)
+FORM1_METRIC_BLOCK_KEYS = (
+    "plan",
+    "reserve",
+    "approved",
+    "collegial",
+    "allocation",
+    "sequestration",
+    "contract",
+    "ckk",
+    "contract_summary",
+)
+
+
+class ExcelValueSerializer:
+    def to_excel_value(self, value: Any) -> Any:
+        if value is None or isinstance(value, (str, int, float, bool)):
+            return value
+        if isinstance(value, dict):
+            for preferred_key in ("name", "title", "label", "value"):
+                preferred_value = value.get(preferred_key)
+                if isinstance(preferred_value, (str, int, float, bool)) and preferred_value is not None:
+                    return preferred_value
+            if len(value) == 1:
+                only_value = next(iter(value.values()))
+                if isinstance(only_value, (str, int, float, bool)) or only_value is None:
+                    return only_value
+            return self._dict_to_readable_text(value)
+        if isinstance(value, (list, tuple)):
+            if all(isinstance(item, (str, int, float, bool)) or item is None for item in value):
+                return ", ".join("" if item is None else str(item) for item in value)
+            return json.dumps(value, ensure_ascii=False)
+        return str(value)
+
+    def _dict_to_readable_text(self, value: dict[str, Any]) -> Any:
+        parts: list[str] = []
+        for key, raw in value.items():
+            normalized = self.to_excel_value(raw)
+            if self._is_empty_excel_value(normalized):
+                continue
+            parts.append(f"{key}={normalized}")
+        if not parts:
+            return None
+        return "; ".join(parts)
+
+    def dict_to_readable_text(self, value: dict[str, Any]) -> Any:
+        return self._dict_to_readable_text(value)
+
+    @staticmethod
+    def _is_empty_excel_value(value: Any) -> bool:
+        if value is None:
+            return True
+        if isinstance(value, str) and value.strip() == "":
+            return True
+        return False
+
+
+class Form1RowNormalizer:
+    def __init__(self, serializer: ExcelValueSerializer):
+        self.serializer = serializer
+
+    def normalize(self, data: dict[str, Any]) -> dict[str, Any]:
+        normalized = dict(data)
+        self._merge_header_fields_into_row(normalized=normalized, original=data)
+        self._promote_quarter_values_from_section_blocks(normalized=normalized)
+        self._collapse_metric_blocks_to_scalar(normalized=normalized)
+        self._fill_contract_fields(normalized=normalized)
+        return normalized
+
+    def _merge_header_fields_into_row(self, normalized: dict[str, Any], original: dict[str, Any]) -> None:
+        header = original.get("header")
+        if isinstance(header, dict):
+            if "section" in header and "section" not in normalized:
+                normalized["section"] = header.get("section")
+            if "item_id" in header and "item_id" not in normalized:
+                normalized["item_id"] = header.get("item_id")
+            if "name" in header and "name" not in normalized:
+                normalized["name"] = header.get("name")
+        normalized.pop("header", None)
+        normalized.pop("line_id", None)
+
+    def _promote_quarter_values_from_section_blocks(self, normalized: dict[str, Any]) -> None:
+        for section_key in FORM1_SECTION_BLOCK_KEYS:
+            section_payload = normalized.get(section_key)
+            if not isinstance(section_payload, dict):
+                continue
+            for quarter_key in QUARTER_KEYS:
+                if normalized.get(quarter_key) is None and section_payload.get(quarter_key) is not None:
+                    normalized[quarter_key] = section_payload.get(quarter_key)
+
+    def _collapse_metric_blocks_to_scalar(self, normalized: dict[str, Any]) -> None:
+        for block_key in FORM1_METRIC_BLOCK_KEYS:
+            block_value = normalized.get(block_key)
+            if isinstance(block_value, dict):
+                normalized[block_key] = self._extract_preferred_metric(block_value)
+
+    def _fill_contract_fields(self, normalized: dict[str, Any]) -> None:
+        contract_summary = normalized.get("contract_summary")
+        contract_detail = normalized.get("contract_detail")
+        if normalized.get("contract") is None:
+            normalized["contract"] = self._extract_contract_label(contract_detail, contract_summary)
+        if isinstance(contract_detail, dict):
+            normalized["contract_sum"] = self._extract_preferred_metric(contract_detail)
+
+    def _extract_preferred_metric(self, payload: dict[str, Any]) -> Any:
+        priority_keys = (
+            "total_year",
+            "year",
+            "totals",
+            "total",
+            "sum",
+            "amount",
+            "value",
+            "approved_amount",
+            "reserved_amount",
+            "allocated_amount",
+            "booked_amount",
+        )
+        for key in priority_keys:
+            if payload.get(key) is not None:
+                return payload.get(key)
+        for quarter_key in ("q1", "q2", "q3", "q4"):
+            if payload.get(quarter_key) is not None:
+                return payload.get(quarter_key)
+        return self.serializer.dict_to_readable_text(payload)
+
+    @staticmethod
+    def _extract_contract_label(contract_detail: Any, contract_summary: Any) -> Any:
+        for payload in (contract_detail, contract_summary):
+            if not isinstance(payload, dict):
+                continue
+            for key in ("reference", "contract_ref", "counterparty", "subject"):
+                value = payload.get(key)
+                if value not in (None, ""):
+                    return value
+        return None
+
+
+class SmetaRowNormalizer:
+    def normalize(self, data: dict[str, Any]) -> dict[str, Any]:
+        return {
+            field: self._pick_nested_value(data, *path)
+            for field, path in SMETA_VALUE_PATHS
+        }
+
+    @staticmethod
+    def _pick_nested_value(container: Any, *path: str) -> Any:
+        cur = container
+        for key in path:
+            if not isinstance(cur, dict):
+                return None
+            cur = cur.get(key)
+        return cur
+
+
+class Form3ReportRowNormalizer:
+    def normalize(self, data: dict[str, Any]) -> dict[str, Any]:
+        normalized = dict(data)
+        header = data.get("header")
+        if isinstance(header, dict):
+            if "section_code" in header and "section" not in normalized:
+                normalized["section"] = header.get("section_code")
+            if "item_id" in header and "item_id" not in normalized:
+                normalized["item_id"] = header.get("item_id")
+            if "name" in header and "name" not in normalized:
+                normalized["name"] = header.get("name")
+        for quarter_key in ("q1", "q2", "q3", "q4"):
+            normalized[quarter_key] = self._extract_quarter_metric(normalized.get(quarter_key))
+        normalized["totals"] = self._extract_totals_metric(normalized.get("totals"))
+        normalized.pop("header", None)
+        normalized.pop("line_id", None)
+        return normalized
+
+    @staticmethod
+    def _extract_quarter_metric(value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        for key in ("quarter_actual", "total_corr", "economy"):
+            if value.get(key) is not None:
+                return value.get(key)
+        return None
+
+    @staticmethod
+    def _extract_totals_metric(value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        for key in ("total_actual", "total_corr", "economy"):
+            if value.get(key) is not None:
+                return value.get(key)
+        return None

api/src/services/export_service.py

@@ -0,0 +1,427 @@
+from __future__ import annotations
+
+import io
+import json
+import zipfile
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import quote
+
+from openpyxl import Workbook
+from openpyxl.worksheet.worksheet import Worksheet
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.app_user import AppUser
+from src.db.models.form_type import FormTypeEnum
+from src.services.budget_form_service import BudgetFormService
+from src.services.export_normalizers import (
+    ExcelValueSerializer,
+    Form1RowNormalizer,
+    Form3ReportRowNormalizer,
+    SmetaRowNormalizer,
+)
+from src.services.export_writers import (
+    FORM1_FLAT_COLUMNS,
+    FORM3_REPORT_COLUMNS,
+    SMETA_COLUMNS,
+    TabularSheetWriter,
+)
+from src.services.project_service import ProjectService
+from src.services.sheet_service import SheetService
+
+XLSX_MEDIA_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+ZIP_MEDIA_TYPE = "application/zip"
+FORM1_DIRECTION_REQUIRED_SHEETS = {"AHR", "CAP"}
+SHEETS_WITH_SECTIONS = {"AHR", "CAP", "OPER"}
+
+
+@dataclass(frozen=True)
+class ExportSheetPlan:
+    sheet_name: str
+    effective_direction: str | None
+    effective_sections: list[str] | None
+    validation_direction: str | None
+    validation_sections: list[str] | None
+
+
+class ExportService:
+    def __init__(self, db: AsyncSession):
+        self.budget_form_service = BudgetFormService(db)
+        self.sheet_service = SheetService(db)
+        self.project_service = ProjectService(db)
+        self.value_serializer = ExcelValueSerializer()
+        self.form1_row_normalizer = Form1RowNormalizer(self.value_serializer)
+        self.form3_report_row_normalizer = Form3ReportRowNormalizer()
+        self.smeta_row_normalizer = SmetaRowNormalizer()
+        self.sheet_writers: dict[str, TabularSheetWriter] = {
+            "__default__": TabularSheetWriter(
+                columns=FORM1_FLAT_COLUMNS,
+                row_normalizer=self.form1_row_normalizer.normalize,
+                value_serializer=self.value_serializer.to_excel_value,
+            ),
+            "SMETA": TabularSheetWriter(
+                columns=SMETA_COLUMNS,
+                row_normalizer=self.smeta_row_normalizer.normalize,
+                value_serializer=self.value_serializer.to_excel_value,
+            ),
+        }
+        self.form3_report_writer = TabularSheetWriter(
+            columns=FORM3_REPORT_COLUMNS,
+            row_normalizer=self.form3_report_row_normalizer.normalize,
+            value_serializer=self.value_serializer.to_excel_value,
+        )
+
+    async def export_form_payload(
+        self,
+        form_id: int,
+        current_user: AppUser,
+        sheet: str | None = None,
+        direction: str | None = None,
+        sections: list[str] | None = None,
+        ignore_non_applicable_query_params: bool = False,
+    ) -> tuple[io.BytesIO, str, str]:
+        stream, filename = await self.export_form_to_xlsx(
+            form_id=form_id,
+            current_user=current_user,
+            sheet=sheet,
+            direction=direction,
+            sections=sections,
+            ignore_non_applicable_query_params=ignore_non_applicable_query_params,
+        )
+        return stream, filename, XLSX_MEDIA_TYPE
+
+    async def export_project_report_payload(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        current_user: AppUser,
+        sections: list[str] | None = None,
+    ) -> tuple[io.BytesIO, str, str]:
+        stream, filename = await self.export_project_report_to_xlsx(
+            project_id=project_id,
+            year=year,
+            report_type=report_type,
+            current_user=current_user,
+            sections=sections,
+        )
+        return stream, filename, XLSX_MEDIA_TYPE
+
+    async def export_bulk_payload(
+        self,
+        form_ids: list[int],
+        current_user: AppUser,
+        skip_failed: bool = True,
+        direction: str | None = None,
+        sections: list[str] | None = None,
+        ignore_non_applicable_query_params: bool = False,
+    ) -> tuple[io.BytesIO, str, str]:
+        archive_stream = io.BytesIO()
+        exported_count = 0
+        errors: list[dict[str, Any]] = []
+        used_names: set[str] = set()
+
+        with zipfile.ZipFile(
+            archive_stream,
+            mode="w",
+            compression=zipfile.ZIP_DEFLATED,
+        ) as archive:
+            for form_id in self._deduplicate_ids(form_ids):
+                try:
+                    form_stream, filename = await self.export_form_to_xlsx(
+                        form_id=form_id,
+                        current_user=current_user,
+                        direction=direction,
+                        sections=sections,
+                        ignore_non_applicable_query_params=ignore_non_applicable_query_params,
+                    )
+                    archive_name = self._make_unique_filename(filename, used_names)
+                    archive.writestr(archive_name, form_stream.getvalue())
+                    exported_count += 1
+                except ValueError as exc:
+                    if not skip_failed:
+                        raise
+                    errors.append({"form_id": form_id, "error": str(exc)})
+
+            if errors:
+                archive.writestr(
+                    "errors.json",
+                    json.dumps({"errors": errors}, ensure_ascii=False, indent=2).encode("utf-8"),
+                )
+
+        if exported_count == 0:
+            raise ValueError("Не удалось экспортировать ни одной формы.")
+
+        archive_stream.seek(0)
+        filename = f"export_forms_{datetime.now(timezone.utc).strftime('%Y-%m-%d')}.zip"
+        return archive_stream, filename, ZIP_MEDIA_TYPE
+
+    async def export_form_to_xlsx(
+        self,
+        form_id: int,
+        current_user: AppUser,
+        sheet: str | None = None,
+        direction: str | None = None,
+        sections: list[str] | None = None,
+        ignore_non_applicable_query_params: bool = False,
+    ) -> tuple[io.BytesIO, str]:
+        form = await self._get_form_for_export(form_id=form_id, current_user=current_user)
+        sheets = self._resolve_requested_sheets(form=form, requested_sheet=sheet)
+        self._validate_sections_for_form(form=form, sections=sections)
+
+        if direction:
+            plans = self._build_sheet_plans(
+                form=form,
+                sheets=sheets,
+                direction=direction,
+                sections=sections,
+                ignore_non_applicable_query_params=ignore_non_applicable_query_params,
+            )
+        else:
+            sheets_by_directions = self._resolve_sheets_by_directions(form=form, requested_sheet=sheet)
+            plans = []
+            for dr, shts in sheets_by_directions.items():
+                plans += self._build_sheet_plans(
+                    form=form,
+                    sheets=shts,
+                    direction=dr,
+                    sections=sections,
+                    ignore_non_applicable_query_params=ignore_non_applicable_query_params,
+                )
+
+
+
+        workbook = self._create_workbook_with_metadata(form=form)
+        exported_sheets = 0
+        for plan in plans:
+            self._validate_sheet_query_params(
+                form_type_code=form.form_type.code,
+                sheet=plan.sheet_name,
+                direction=plan.validation_direction,
+                sections=plan.validation_sections,
+            )
+            rows = await self.sheet_service.get(
+                form_id=form_id,
+                sheet=plan.sheet_name,
+                direction=plan.effective_direction,
+                sections=plan.effective_sections,
+            )
+            worksheet = workbook.create_sheet(title=self._safe_sheet_name(plan.sheet_name))
+            self._write_sheet_rows(
+                worksheet=worksheet,
+                rows=rows,
+                sheet_name=plan.sheet_name,
+            )
+            exported_sheets += 1
+
+        if exported_sheets == 0:
+            raise ValueError("Не удалось экспортировать листы формы.")
+
+        stream = io.BytesIO()
+        workbook.save(stream)
+        workbook.close()
+        stream.seek(0)
+        filename = self._build_filename(form_id=form.id, form_type_code=form.form_type.code, year=form.year, sheet=sheet)
+        return stream, filename
+
+    async def export_project_report_to_xlsx(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        current_user: AppUser,
+        sections: list[str] | None = None,
+    ) -> tuple[io.BytesIO, str]:
+        rows = await self.project_service.get_report_rows(
+            project_id=project_id,
+            year=year,
+            report_type=report_type,
+            sections=sections,
+            user=current_user,
+        )
+        report_type_upper = report_type.upper()
+        workbook = Workbook()
+        meta_sheet = workbook.active
+        meta_sheet.title = "metadata"
+        metadata_rows = [
+            ("Тип формы", "FORM_3"),
+            ("Project ID", project_id),
+            ("Year", year),
+            ("Report Type", report_type_upper),
+            ("Sections", ", ".join(sections) if sections else None),
+            ("Экспортировано", datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")),
+        ]
+        for row_idx, (key, value) in enumerate(metadata_rows, start=1):
+            meta_sheet.cell(row=row_idx, column=1, value=key)
+            meta_sheet.cell(row=row_idx, column=2, value=value)
+        worksheet = workbook.create_sheet(title=self._safe_sheet_name(report_type_upper))
+        self.form3_report_writer.write(worksheet, rows)
+        stream = io.BytesIO()
+        workbook.save(stream)
+        workbook.close()
+        stream.seek(0)
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        filename = f"{year}_FORM_3_{project_id}_{report_type_upper}_{date_str}.xlsx"
+        return stream, filename
+
+    @staticmethod
+    def build_content_disposition(filename: str) -> str:
+        encoded = quote(filename)
+        return f"attachment; filename*=UTF-8''{encoded}"
+
+    def _fill_metadata(self, sheet: Worksheet, form: Any) -> None:
+        metadata_rows = [
+            ("Форма ID", form.id),
+            ("Тип формы", form.form_type_code),
+            ("Год", form.year),
+            ("Org Unit ID", form.org_unit_id),
+            ("Org Unit", form.org_unit.title if form.org_unit else None),
+            ("Экспортировано", datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")),
+        ]
+        for row_idx, (key, value) in enumerate(metadata_rows, start=1):
+            sheet.cell(row=row_idx, column=1, value=key)
+            sheet.cell(row=row_idx, column=2, value=value)
+
+    def _write_sheet_rows(
+        self,
+        worksheet: Worksheet,
+        rows: list[tuple],
+        sheet_name: str,
+    ) -> None:
+        writer = self.sheet_writers.get(sheet_name, self.sheet_writers["__default__"])
+        writer.write(worksheet, rows)
+
+    async def _get_form_for_export(self, form_id: int, current_user: AppUser) -> Any:
+        form = await self.budget_form_service.get(
+            budget_form_id=form_id,
+            user=current_user,
+            load_form_type=True,
+            load_org=True,
+        )
+        if not form:
+            raise ValueError(f"Форма {form_id} не найдена")
+        return form
+
+    def _resolve_requested_sheets(self, form: Any, requested_sheet: str | None) -> list[str]:
+        if requested_sheet and requested_sheet not in form.form_type.sheet_list:
+            raise ValueError(f"Лист {requested_sheet} формы {form.id} не найден")
+        if requested_sheet:
+            return [requested_sheet]
+        return list(form.form_type.sheet_list)
+    
+    def _resolve_sheets_by_directions(self, form: Any, requested_sheet: str | None) -> dict[str | None, str]:
+        result = {}
+        for sheet in form.form_type.sheet_list_with_directions:
+            if requested_sheet and sheet["sheet_name"] != requested_sheet:
+                continue
+
+            if sheet["direction"] in result:
+                result[sheet["direction"]].append(sheet["sheet_name"])
+            else:
+                result[sheet["direction"]] = [sheet["sheet_name"]]
+        return result
+
+    @staticmethod
+    def _validate_sections_for_form(form: Any, sections: list[str] | None) -> None:
+        if not sections:
+            return
+        invalid = sorted(set(sections) - set(form.form_type.section_list))
+        if invalid:
+            raise ValueError(f"Недопустимые sections: {', '.join(invalid)}")
+
+    def _create_workbook_with_metadata(self, form: Any) -> Workbook:
+        workbook = Workbook()
+        meta_sheet = workbook.active
+        meta_sheet.title = "metadata"
+        self._fill_metadata(meta_sheet, form)
+        return workbook
+
+    def _build_sheet_plans(
+        self,
+        form: Any,
+        sheets: list[str],
+        direction: str | None,
+        sections: list[str] | None,
+        ignore_non_applicable_query_params: bool,
+    ) -> list[ExportSheetPlan]:
+        plans: list[ExportSheetPlan] = []
+        for sheet_name in sheets:
+            effective_direction = direction if self._requires_direction(form.form_type.code, sheet_name) else None
+            effective_sections = sections if sheet_name in SHEETS_WITH_SECTIONS else None
+            validation_direction = effective_direction if ignore_non_applicable_query_params else direction
+            validation_sections = effective_sections if ignore_non_applicable_query_params else sections
+            plans.append(
+                ExportSheetPlan(
+                    sheet_name=sheet_name,
+                    effective_direction=effective_direction,
+                    effective_sections=effective_sections,
+                    validation_direction=validation_direction,
+                    validation_sections=validation_sections,
+                )
+            )
+        return plans
+
+
+    def _validate_sheet_query_params(
+        self,
+        form_type_code: FormTypeEnum,
+        sheet: str,
+        direction: str | None,
+        sections: list[str] | None,
+    ) -> None:
+        if form_type_code == FormTypeEnum.FORM_1 and sheet in FORM1_DIRECTION_REQUIRED_SHEETS and not direction:
+            raise ValueError("direction обязателен для FORM_1 листов AHR/CAP")
+        if direction and not self._requires_direction(form_type_code, sheet):
+            raise ValueError("direction допустим только для FORM_1 листов AHR/CAP")
+        if sections and sheet not in SHEETS_WITH_SECTIONS:
+            raise ValueError(f"sections не поддерживается для листа {sheet}")
+
+    @staticmethod
+    def _requires_direction(form_type_code: FormTypeEnum, sheet: str) -> bool:
+        return form_type_code == FormTypeEnum.FORM_1 and sheet in FORM1_DIRECTION_REQUIRED_SHEETS
+
+    @staticmethod
+    def _safe_sheet_name(value: str) -> str:
+        safe = value
+        for char in ("[", "]", ":", "*", "?", "/", "\\"):
+            safe = safe.replace(char, "_")
+        safe = safe.strip()
+        return (safe or "Sheet")[:31]
+
+    @staticmethod
+    def _build_filename(form_id: int, form_type_code: str, year: int, sheet: str | None = None) -> str:
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+        if sheet:
+            return f"{year}_{form_type_code}_{form_id}_{sheet}_{date_str}.xlsx"
+        return f"{year}_{form_type_code}_{form_id}_{date_str}.xlsx"
+
+    @staticmethod
+    def _deduplicate_ids(form_ids: list[int]) -> list[int]:
+        seen: set[int] = set()
+        result: list[int] = []
+        for form_id in form_ids:
+            if form_id not in seen:
+                seen.add(form_id)
+                result.append(form_id)
+        return result
+
+    @staticmethod
+    def _make_unique_filename(filename: str, used_names: set[str]) -> str:
+        if filename not in used_names:
+            used_names.add(filename)
+            return filename
+
+        if "." in filename:
+            base, ext = filename.rsplit(".", 1)
+            ext = f".{ext}"
+        else:
+            base, ext = filename, ""
+
+        suffix = 2
+        while True:
+            candidate = f"{base}_{suffix}{ext}"
+            if candidate not in used_names:
+                used_names.add(candidate)
+                return candidate
+            suffix += 1

api/src/services/export_writers.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from openpyxl.worksheet.worksheet import Worksheet
+
+FORM1_FLAT_COLUMNS: list[tuple[str, str]] = [
+    ("section", "Код раздела"),
+    ("item_id", "ID статьи"),
+    ("name", "Наименование"),
+    ("q1", "I квартал"),
+    ("q2", "II квартал"),
+    ("q3", "III квартал"),
+    ("q4", "IV квартал"),
+    ("totals", "ИТОГО"),
+    ("plan", "План"),
+    ("reserve", "Резерв"),
+    ("approved", "Согласовано"),
+    ("collegial", "Коллегиальный"),
+    ("allocation", "Аллокация"),
+    ("sequestration", "Секвестр"),
+    ("contract", "Договор"),
+    ("contract_sum", "Сумма договора"),
+    ("ckk", "ЦКК"),
+]
+
+SMETA_COLUMNS: list[tuple[str, str]] = [
+    ("section_code", "Код раздела"),
+    ("name", "Наименование"),
+    ("plan_support_q1", "План поддержка I квартал"),
+    ("plan_support_q2", "План поддержка II квартал"),
+    ("plan_support_q3", "План поддержка III квартал"),
+    ("plan_support_q4", "План поддержка IV квартал"),
+    ("plan_support_year", "План поддержка Год"),
+    ("plan_development_q1", "План развитие I квартал"),
+    ("plan_development_q2", "План развитие II квартал"),
+    ("plan_development_q3", "План развитие III квартал"),
+    ("plan_development_q4", "План развитие IV квартал"),
+    ("plan_development_year", "План развитие Год"),
+    ("plan_total_year", "План ИТОГО Год"),
+    ("approved_support_q1", "Утверждено поддержка I квартал"),
+    ("approved_support_q2", "Утверждено поддержка II квартал"),
+    ("approved_support_q3", "Утверждено поддержка III квартал"),
+    ("approved_support_q4", "Утверждено поддержка IV квартал"),
+    ("approved_support_year", "Утверждено поддержка Год"),
+    ("approved_development_q1", "Утверждено развитие I квартал"),
+    ("approved_development_q2", "Утверждено развитие II квартал"),
+    ("approved_development_q3", "Утверждено развитие III квартал"),
+    ("approved_development_q4", "Утверждено развитие IV квартал"),
+    ("approved_development_year", "Утверждено развитие Год"),
+    ("approved_total_year", "Утверждено ИТОГО Год"),
+    ("fact_support_q1", "Факт поддержка I квартал"),
+    ("fact_support_q2", "Факт поддержка II квартал"),
+    ("fact_support_q3", "Факт поддержка III квартал"),
+    ("fact_support_q4", "Факт поддержка IV квартал"),
+    ("fact_support_year", "Факт поддержка Год"),
+    ("fact_development_q1", "Факт развитие I квартал"),
+    ("fact_development_q2", "Факт развитие II квартал"),
+    ("fact_development_q3", "Факт развитие III квартал"),
+    ("fact_development_q4", "Факт развитие IV квартал"),
+    ("fact_development_year", "Факт развитие Год"),
+    ("fact_total_year", "Факт ИТОГО Год"),
+    ("corrected_support_q2", "Корректировка поддержка II квартал"),
+    ("corrected_support_q3", "Корректировка поддержка III квартал"),
+    ("corrected_support_q4", "Корректировка поддержка IV квартал"),
+    ("corrected_development_q2", "Корректировка развитие II квартал"),
+    ("corrected_development_q3", "Корректировка развитие III квартал"),
+    ("corrected_development_q4", "Корректировка развитие IV квартал"),
+]
+FORM3_REPORT_COLUMNS: list[tuple[str, str]] = [
+    ("section", "Код раздела"),
+    ("item_id", "ID статьи"),
+    ("name", "Наименование"),
+    ("q1", "I квартал"),
+    ("q2", "II квартал"),
+    ("q3", "III квартал"),
+    ("q4", "IV квартал"),
+    ("totals", "ИТОГО"),
+]
+
+RowNormalizer = Callable[[dict[str, Any]], dict[str, Any]]
+ValueSerializer = Callable[[Any], Any]
+
+
+class TabularSheetWriter:
+    def __init__(
+        self,
+        columns: list[tuple[str, str]],
+        row_normalizer: RowNormalizer,
+        value_serializer: ValueSerializer,
+    ):
+        self.columns = columns
+        self.row_normalizer = row_normalizer
+        self.value_serializer = value_serializer
+
+    def write(self, worksheet: Worksheet, rows: list[tuple]) -> None:
+        worksheet.append([title for _, title in self.columns])
+        for row in rows:
+            raw_data = row[3] if len(row) > 3 and isinstance(row[3], dict) else {}
+            normalized = self.row_normalizer(raw_data)
+            worksheet.append(
+                [self.value_serializer(normalized.get(key)) for key, _ in self.columns]
+            )

api/src/services/form_phase_service.py

@@ -0,0 +1,139 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.core.errors import AccessDeniedException, ValidationsError
+from src.db.models.budget_form import BudgetForm
+from src.db.models.role import UserRoleEnum
+from src.repository.budget_form_repository import BudgetFormRepository
+from src.db.models.app_user import AppUser
+from src.db.models.form_phase import FormPhase
+from src.domain.schemas import FormPhaseCreate, FormPhaseUpdate
+from src.repository.form_phase_repository import FormPhaseRepository
+
+
+class FormPhaseService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+        self.fp_repo = FormPhaseRepository(db)
+        self.bf_repo = BudgetFormRepository(db)
+
+    async def get_list(
+        self,
+        budget_form_id: int,
+        user: AppUser,
+        sheet: str | None = None,
+        phase_code: str | None = None,
+    ) -> list[FormPhase]:
+        return await self.fp_repo.get_list(
+            budget_form_id=budget_form_id,
+            sheet=sheet,
+            phase_code=phase_code,
+        )
+
+    async def get(
+        self, budget_form_id: int, sheet: str, phase_code: str, user: AppUser
+    ) -> FormPhase | None:
+        return await self.fp_repo.get(
+            budget_form_id=budget_form_id,
+            sheet=sheet,
+            phase_code=phase_code,
+        )
+
+    def _validate_form_phase(
+            self,
+            form_phase: FormPhaseCreate | FormPhaseUpdate,
+            budget_form: BudgetForm,
+            sheet: str | None = None,
+    ) -> None:
+        errors = {}
+        if budget_form.form_type.sheet_list:
+            sheet = sheet or form_phase.sheet
+            if sheet not in budget_form.form_type.sheet_list:
+                errors["sheet"] = [f"У формы нет листа {sheet}"]
+        if form_phase.column_keys and budget_form.form_type.section_list:
+            for column_key in form_phase.column_keys:
+                section = column_key.split(".")
+                if section[0] not in budget_form.form_type.section_list:
+                    if "column_keys" in errors:
+                        errors["column_keys"].append(f"Колонка {column_key} некорректна")
+                    else:
+                        errors["column_keys"] = [f"Колонка {column_key} некорректна"]
+        if errors:
+            raise ValidationsError(errors=errors)
+
+
+    async def create(
+            self,  
+            body: FormPhaseCreate, 
+            user: AppUser,
+            budget_form_id: int | None = None,
+            budget_form: BudgetForm | None = None,
+    ) -> FormPhase:
+        assert budget_form or budget_form_id
+        if user.role_id != UserRoleEnum.ADMIN:
+            raise AccessDeniedException
+        
+        if not budget_form or budget_form.form_type is None:
+            budget_form = await self.bf_repo.get(
+                budget_form_id=budget_form_id or budget_form.id,
+                load_form_type=True,
+            )
+        self._validate_form_phase(
+            form_phase=body,
+            budget_form=budget_form,
+        )
+        return await self.fp_repo.create(
+            budget_form_id=budget_form_id or budget_form.id,
+            sheet=body.sheet,
+            phase_code=body.phase_code,
+            role=body.role,
+            column_keys=body.column_keys,
+            opens_at=body.opens_at,
+            closes_at=body.closes_at,
+        )
+
+    async def update(
+            self,
+            sheet: str,
+            phase_code: str,
+            body: FormPhaseUpdate,
+            user: AppUser,
+            budget_form_id: int | None = None,
+            budget_form: BudgetForm | None = None,
+    ) -> FormPhase:
+        assert budget_form or budget_form_id
+        if user.role_id != UserRoleEnum.ADMIN:
+            raise AccessDeniedException
+        
+        if not budget_form or budget_form.form_type is None:
+            budget_form = await self.bf_repo.get(
+                budget_form_id=budget_form_id or budget_form.id,
+                load_form_type=True,
+            )
+        self._validate_form_phase(
+            form_phase=body,
+            budget_form=budget_form,
+            sheet=sheet,
+        )
+
+        data = body.model_dump(exclude_unset=True)
+        if not data:
+            return await self.fp_repo.get(
+                budget_form_id=budget_form_id or budget_form.id,
+                sheet=sheet,
+                phase_code=phase_code,
+            )
+        return await self.fp_repo.update(
+            budget_form_id=budget_form_id or budget_form.id,
+            sheet=sheet,
+            phase_code=phase_code,
+            data=data,
+        )
+
+    async def delete(
+        self, budget_form_id: int, sheet: str, phase_code: str, user: AppUser
+    ) -> bool:
+        return await self.fp_repo.delete(
+            budget_form_id=budget_form_id,
+            sheet=sheet,
+            phase_code=phase_code,
+        )

api/src/services/org_unit_service.py

@@ -0,0 +1,102 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.core.errors import AccessDeniedException
+from src.db.models.app_user import AppUser
+from src.db.models.org_unit import OrgUnit
+from src.db.models.role import UserRoleEnum
+from src.repository.org_unit_repository import OrgUnitRepository
+
+
+
+class OrgUnitService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+        self.org_repo = OrgUnitRepository(db)
+
+    async def get_list(
+            self,
+            user: AppUser,
+            offset: int | None = None,
+            limit: int | None = None,
+            is_ssp: bool | None = None,
+            is_active: bool | None = None,
+            with_count: bool = False,
+            load_users: bool = False,
+    ) -> list[OrgUnit] | tuple[int, list[OrgUnit]]:
+        if user.role_id != UserRoleEnum.ADMIN:
+            return (0, []) if with_count else []
+
+        return await self.org_repo.get_list(
+            offset=offset,
+            limit=limit,
+            with_count=with_count,
+            is_ssp=is_ssp,
+            is_active=is_active,
+            load_users=load_users,
+        )
+
+    async def get(
+            self,
+            org_unit_id: int,
+            user: AppUser,
+            load_users: bool = False,
+    ) -> OrgUnit | None:
+        if user.role_id != UserRoleEnum.ADMIN:
+            return None
+        return await self.org_repo.get(
+            org_unit_id=org_unit_id,
+            load_users=load_users,
+        )
+    
+    async def create(
+            self, 
+            title: str,
+            is_ssp: bool,
+            user: AppUser,
+    ) -> OrgUnit:
+        """Создание нового ССП/РФ."""
+        if not self._can_create_ssp(user):
+            raise AccessDeniedException()
+
+        return await self.org_repo.create(
+            title=title,
+            is_ssp=is_ssp,
+        )
+    
+    async def update(
+        self, org_unit_id: int, user: AppUser, **kwargs
+    ) -> OrgUnit | None:
+        """Редактирование ССП/РФ"""
+        #ToDo: писать логи
+        if not self._can_edit_ssp(user):
+            raise AccessDeniedException()
+
+        org_unit = await self.org_repo.get(org_unit_id=org_unit_id)
+
+        if not org_unit:
+            return None
+
+        return await self.org_repo.update(
+            org_unit=org_unit, **kwargs,
+        )
+
+    async def logical_delete(
+            self, 
+            org_unit_id: int, 
+            user: AppUser,
+            is_active: bool | None = None,
+    ) -> bool:
+        """Логическое удаление ССП/РФ"""
+        if not self._can_delete_ssp(user):
+            raise AccessDeniedException()
+
+        return bool(await self.org_repo.logical_delete(org_unit_id=org_unit_id, is_active=is_active))
+
+    def _can_create_ssp(self, user: AppUser) -> bool:
+        return user.role_id == UserRoleEnum.ADMIN
+
+    def _can_edit_ssp(self, user: AppUser) -> bool:
+        return user.role_id == UserRoleEnum.ADMIN
+
+    def _can_delete_ssp(self, user: AppUser) -> bool:
+        return user.role_id == UserRoleEnum.ADMIN

api/src/services/project_service.py

@@ -0,0 +1,191 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.app_user import AppUser
+from src.db.models.role import UserRoleEnum
+from src.core.errors import AccessDeniedException, ValidationException
+from src.repository.project_repository import ProjectRepository
+from src.repository.user_repository import UserRepository
+
+
+class ProjectService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+        self.project_repo = ProjectRepository(db)
+        self.user_repo = UserRepository(db)
+
+    async def get_list(
+        self,
+        user: AppUser,
+        year: int | None = None,
+        branch_id: int | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+        with_count: bool = False,
+        with_org_unit: bool = False,
+    ) -> list[dict] | tuple[int, list[dict]]:
+        org_unit_ids = await self._allowed_org_unit_ids(user)
+        return await self.project_repo.get_list(
+            year=year,
+            branch_id=branch_id,
+            offset=offset,
+            limit=limit,
+            with_count=with_count,
+            org_unit_ids=org_unit_ids,
+        )
+
+    async def get(self, project_id: int, user: AppUser) -> dict | None:
+        org_unit_ids = await self._allowed_org_unit_ids(user)
+        project = await self.project_repo.get(project_id=project_id, org_unit_ids=org_unit_ids)
+        if not project:
+            return None
+        project["reports"] = await self.project_repo.get_reports(project_id=project_id)
+        return project
+
+    async def resolve_report_id(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        user: AppUser,
+    ) -> int | None:
+        normalized_type = report_type.upper()
+        if normalized_type not in ("LIMIT", "CURRENT_EXPENSES"):
+            raise ValidationException("report_type должен быть LIMIT или CURRENT_EXPENSES")
+        org_unit_ids = await self._allowed_org_unit_ids(user)
+        return await self.project_repo.resolve_report_id(
+            project_id=project_id,
+            year=year,
+            report_type=normalized_type,
+            org_unit_ids=org_unit_ids,
+        )
+
+    async def get_report_rows(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        sections: list[str] | None,
+        user: AppUser,
+    ) -> list[tuple]:
+        report_id = await self.resolve_report_id(project_id, year, report_type, user)
+        if not report_id:
+            raise ValidationException("Отчёт не найден")
+        return await self.project_repo.get_report_rows(report_id=report_id, sections=sections)
+
+    async def get_rf_rollup_rows(
+        self,
+        branch_id: int,
+        year: int,
+        sections: list[str] | None,
+        user: AppUser,
+    ) -> list[tuple]:
+        org_unit_ids = await self._allowed_org_unit_ids(user)
+        if org_unit_ids is not None and branch_id not in org_unit_ids:
+            raise AccessDeniedException()
+        return await self.project_repo.get_rf_rollup_rows(
+            branch_id=branch_id,
+            year=year,
+            sections=sections,
+        )
+
+    async def upd_form3_cell(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        line_id: int,
+        column: str,
+        value,
+        user: AppUser,
+    ) -> list[tuple]:
+        report_id = await self.resolve_report_id(project_id, year, report_type, user)
+        if not report_id:
+            raise ValidationException("Отчёт не найден")
+        return await self.project_repo.upd_form3_cell(report_id, line_id, column, value)
+
+    async def upd_form3_cells(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        changes: list[dict],
+        user: AppUser,
+    ) -> list[tuple]:
+        report_id = await self.resolve_report_id(project_id, year, report_type, user)
+        if not report_id:
+            raise ValidationException("Отчёт не найден")
+        return await self.project_repo.upd_form3_cells(report_id, changes)
+
+    async def add_form3_line(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        expense_item_id: int,
+        user: AppUser,
+    ) -> list[tuple]:
+        report_id = await self.resolve_report_id(project_id, year, report_type, user)
+        if not report_id:
+            raise ValidationException("Отчёт не найден")
+        return await self.project_repo.add_form3_line(report_id, expense_item_id)
+
+    async def del_form3_line(
+        self,
+        project_id: int,
+        year: int,
+        report_type: str,
+        line_id: int,
+        user: AppUser,
+    ) -> list[tuple]:
+        report_id = await self.resolve_report_id(project_id, year, report_type, user)
+        if not report_id:
+            raise ValidationException("Отчёт не найден")
+        return await self.project_repo.del_form3_line(line_id)
+
+    async def upd_project(
+        self,
+        project_id: int,
+        column: str,
+        value,
+        user: AppUser,
+    ):
+        project = await self.get(project_id, user)
+        if not project:
+            raise ValidationException("Проект не найден")
+        return await self.project_repo.upd_project(project_id, column, value)
+
+    async def add_project(
+        self,
+        name: str,
+        year: int,
+        org_unit_id: int,
+        level: str = "project",
+        parent_id: int | None = None,
+        project_type: str | None = None,
+        vsp_format: str | None = None,
+        placement_type: str | None = None,
+        object_address: str | None = None,
+        staff_count: int | None = None,
+        total_area: float | None = None,
+    ) -> tuple[int, int, int]:
+        return await self.project_repo.add_project(
+            name=name,
+            year=year,
+            org_unit_id=org_unit_id,
+            level=level,
+            parent_id=parent_id,
+            project_type=project_type,
+            vsp_format=vsp_format,
+            placement_type=placement_type,
+            object_address=object_address,
+            staff_count=staff_count,
+            total_area=total_area,
+        )
+
+    async def _allowed_org_unit_ids(self, user: AppUser) -> list[int] | None:
+        if user.role_id == UserRoleEnum.ADMIN:
+            return None
+        db_user = await self.user_repo.get(user_id=user.id, load_orgs=True)
+        if not db_user:
+            return []
+        return [ou.id for ou in db_user.org_units]

api/src/services/sheet_service.py

@@ -0,0 +1,139 @@
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.db.models.app_user import AppUser
+from src.db.models.budget_form import BudgetForm
+from src.repository.sheet_repository import SheetRepository
+
+
+
+class SheetService:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+        self.sheet_repo = SheetRepository(db)
+
+    async def get(
+            self, 
+            sheet: str, 
+            direction: str | None, 
+            sections: list[str] | None = None,
+            form_id: int | None = None,
+            form: BudgetForm | None = None
+    ) -> list[tuple]:        
+        return await self.sheet_repo.get(
+            form_id=form_id,
+            sheet=sheet,
+            direction=direction,
+            sections=sections,
+        )
+    
+    async def update_cell(
+            self, 
+            form_id: int, 
+            sheet: str,
+            direction: str | None,
+            sections: list[str] | None,
+            line_id: int, 
+            column: str, 
+            value: str | int | float | None = None, 
+            user: AppUser | None = None,
+    ) -> list[tuple]:
+        return await self.sheet_repo.update_cell(
+            form_id=form_id, 
+            sheet=sheet,
+            direction=direction,
+            sections=sections,
+            line_id=line_id, 
+            column=column, 
+            value=value, 
+            user_id=user.id if user else None,
+        )
+
+    async def update_cells(
+            self, 
+            form_id: int, 
+            sheet: str,
+            direction: str | None,
+            sections: list[str] | None,
+            changes: list[dict],
+            user: AppUser | None = None,
+    ) -> list[tuple]:
+        return await self.sheet_repo.update_cells(
+            form_id=form_id, 
+            sheet=sheet,
+            direction=direction,
+            sections=sections,
+            changes=changes,
+            user_id=user.id if user else None,
+        )
+    
+    async def update_cell(
+            self, 
+            form_id: int, 
+            sheet: str,
+            direction: str | None,
+            sections: list[str] | None,
+            line_id: int, 
+            column: str, 
+            value: str | int | float | None = None, 
+            user: AppUser | None = None,
+    ) -> list[tuple]:
+        return await self.sheet_repo.update_cell(
+            form_id=form_id, 
+            sheet=sheet,
+            direction=direction,
+            sections=sections,
+            line_id=line_id, 
+            column=column, 
+            value=value, 
+            user_id=user.id if user else None,
+        )
+
+
+    async def add_line(
+            self, 
+            form_id: int,
+            sheet: str,
+            expense_item_id: int | None = None,
+            item_id: str | None = None,
+            section_code: str | None = None,
+            direction: str | None = None,
+            name: str | None = None,
+            internal_order: str | None = None,
+            vsp_id: int | None = None,
+            project_id: int | None = None,
+            justification: str | None = None,
+            contract_number: str | None = None,
+            contract_end_date: str | None = None,
+            user: AppUser | None = None,
+    ) -> list[tuple]:
+        return await self.sheet_repo.add_line(
+            form_id=form_id,
+            sheet=sheet,
+            expense_item_id=expense_item_id,
+            item_id=item_id,
+            section_code=section_code,
+            direction=direction,
+            name=name,
+            internal_order=internal_order,
+            vsp_id=vsp_id,
+            project_id=project_id,
+            justification=justification,
+            contract_number=contract_number,
+            contract_end_date=contract_end_date,
+            user_id=user.id if user else None,
+        )
+
+    async def delete_line(
+            self,
+            form_id: int,
+            sheet: str,
+            row_id: int,
+            direction: str | None = None,
+            user: AppUser | None = None,
+    ) -> list[tuple]:
+        return await self.sheet_repo.delete_line(
+            sheet=sheet,
+            row_id=row_id,
+            direction=direction,
+        )

api/src/services/user_service.py

@@ -1,12 +1,13 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from src.db.models.app_user import AppUser
+from src.db.models.role import UserRoleEnum
 from src.core.errors import (
     AccessDeniedException,
     UserNotFoundException,
     ValidationException,
     UsernameConflictException,
 )
-from src.domain.models import UserRole, Users
 from src.domain.schemas import UserCreate, UserUpdate
 from src.repository.user_repository import UserRepository
 
@@ -16,23 +17,40 @@ class UserService:
         self.db = db
         self.user_repo = UserRepository(db)
 
-    async def get_all(self, current_user: Users, skip: int = 0, limit: int = 100):
-        if current_user.role_id != UserRole.ADMIN:
+    async def get_all(
+            self, 
+            current_user: AppUser, 
+            skip: int = 0, 
+            limit: int = 100,
+            with_count: bool = False,
+            load_orgs: bool = False,
+    ) -> list[AppUser] | tuple[int, list[AppUser]]:
+        if current_user.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
-        return await self.user_repo.get_list(skip=skip, limit=limit)
+        return await self.user_repo.get_list(
+            skip=skip, 
+            limit=limit, 
+            with_count=with_count, 
+            load_orgs=load_orgs,
+        )
 
-    async def get(self, user_id: int, current_user: Users):
-        if current_user.role_id != UserRole.ADMIN:
+    async def get(
+            self, 
+            user_id: int, 
+            current_user: AppUser | None = None, 
+            load_orgs: bool = False,
+    ):
+        if current_user is not None and current_user.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
-        return await self.user_repo.get(user_id)
+        return await self.user_repo.get(user_id=user_id, load_orgs=load_orgs)
 
-    async def create_user(self, user_data: UserCreate, creator: Users):
-        if creator.role_id != UserRole.ADMIN:
+    async def create_user(self, user_data: UserCreate, creator: AppUser):
+        if creator.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
 
-        role_id = user_data.role_id or UserRole.EXECUTOR_RF.value
+        role_id = user_data.role_id or UserRoleEnum.EXECUTOR_RF.value
         try:
-            role = UserRole(role_id)
+            role = UserRoleEnum(role_id)
         except ValueError:
             raise ValidationException("Роль не найдена", field="role_id")
         user_data.role_id = role.value
@@ -43,8 +61,8 @@ class UserService:
         payload = user_data.model_dump(mode="json")
         return await self.user_repo.create(payload)
 
-    async def update_user(self, user_id: int, user_data: UserUpdate, user: Users):
-        if user.role_id != UserRole.ADMIN:
+    async def update_user(self, user_id: int, user_data: UserUpdate, user: AppUser):
+        if user.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
 
         target = await self.user_repo.get(user_id)
@@ -57,7 +75,7 @@ class UserService:
         role = None
         if role_id is not None:
             try:
-                role = UserRole(role_id)
+                role = UserRoleEnum(role_id)
             except ValueError:
                 raise ValidationException("Роль не найдена", field="role_id")
 
@@ -72,47 +90,55 @@ class UserService:
             if conflict:
                 raise UsernameConflictException()
 
-        updated = await self.user_repo.update(user_id, update_payload)
+        updated = await self.user_repo.update(
+            user_id=user_id, 
+            user_data=update_payload,
+            load_orgs=user_data.load_orgs,
+        )
 
         if role_id is not None and role is not None:
             had_many_ssp_role = previous_role_id in (
-                UserRole.ADMIN.value,
-                UserRole.EXECUTOR_DFIP.value,
+                UserRoleEnum.ADMIN.value,
+                UserRoleEnum.EXECUTOR_DFIP.value,
             )
             has_many_ssp_role_now = role.value in (
-                UserRole.ADMIN.value,
-                UserRole.EXECUTOR_DFIP.value,
+                UserRoleEnum.ADMIN.value,
+                UserRoleEnum.EXECUTOR_DFIP.value,
             )
             is_executor_to_dfip_transition = (
-                previous_role_id == UserRole.EXECUTOR_RF.value
-                and role.value == UserRole.EXECUTOR_DFIP.value
+                previous_role_id == UserRoleEnum.EXECUTOR_RF.value
+                and role.value == UserRoleEnum.EXECUTOR_DFIP.value
             )
             if (had_many_ssp_role and not has_many_ssp_role_now) or is_executor_to_dfip_transition:
                 await self.user_repo.clear_many_ssp(user_id)
-
+                if user_data.load_orgs:
+                    updated = await self.user_repo.get(
+                        user_id=user_id,
+                        load_orgs=user_data.load_orgs,
+                    )
         return updated
 
-    async def delete_user(self, user_id: int, user: Users):
-        if user.role_id != UserRole.ADMIN:
+    async def delete_user(self, user_id: int, user: AppUser):
+        if user.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
         deleted = await self.user_repo.logical_delete(user_id)
         if not deleted:
             raise UserNotFoundException()
 
-    async def get_roles(self, current_user: Users):
-        if current_user.role_id != UserRole.ADMIN:
+    async def get_roles(self, current_user: AppUser):
+        if current_user.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
         return await self.user_repo.get_roles()
 
-    async def get_many_ssp(self, user_id: int, current_user: Users):
-        if current_user.role_id == UserRole.ADMIN:
+    async def get_many_ssp(self, user_id: int, current_user: AppUser):
+        if current_user.role_id == UserRoleEnum.ADMIN:
             return await self.user_repo.get_many_ssp(user_id)
         if current_user.id != user_id:
             raise AccessDeniedException()
         return await self.user_repo.get_many_ssp(user_id)
 
-    async def set_many_ssp(self, user_id: int, ssp_ids: list[int], current_user: Users):
-        if current_user.role_id != UserRole.ADMIN:
+    async def set_many_ssp(self, user_id: int, ssp_ids: list[int], current_user: AppUser):
+        if current_user.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
 
         user = await self.user_repo.get(user_id)
@@ -121,9 +147,9 @@ class UserService:
 
         target_role_id = self._normalize_role_id(user.role_id)
         if target_role_id not in (
-            UserRole.ADMIN.value,
-            UserRole.EXECUTOR_DFIP.value,
-            UserRole.EXECUTOR_RF.value,
+            UserRoleEnum.ADMIN.value,
+            UserRoleEnum.EXECUTOR_DFIP.value,
+            UserRoleEnum.EXECUTOR_RF.value,
         ):
             err = AccessDeniedException()
             err.description = (
@@ -132,7 +158,7 @@ class UserService:
             raise err
 
         curr_ssp_ids = await self.user_repo.get_many_ssp_ids(user_id)
-        if target_role_id == UserRole.EXECUTOR_RF.value:
+        if target_role_id == UserRoleEnum.EXECUTOR_RF.value:
             merged_ssp_ids = set(curr_ssp_ids) | set(ssp_ids)
             if len(merged_ssp_ids) > 1:
                 raise ValidationException(
@@ -141,8 +167,8 @@ class UserService:
         new_ssp_ids = [ssp_id for ssp_id in ssp_ids if ssp_id not in curr_ssp_ids]
         return await self.user_repo.set_many_ssp(user.id, new_ssp_ids)
 
-    async def unset_many_ssp(self, user_id: int, ssp_ids: list[int], current_user: Users):
-        if current_user.role_id != UserRole.ADMIN:
+    async def unset_many_ssp(self, user_id: int, ssp_ids: list[int], current_user: AppUser):
+        if current_user.role_id != UserRoleEnum.ADMIN:
             raise AccessDeniedException()
 
         user = await self.user_repo.get(user_id)
@@ -151,9 +177,9 @@ class UserService:
 
         target_role_id = self._normalize_role_id(user.role_id)
         if target_role_id not in (
-            UserRole.ADMIN.value,
-            UserRole.EXECUTOR_DFIP.value,
-            UserRole.EXECUTOR_RF.value,
+            UserRoleEnum.ADMIN.value,
+            UserRoleEnum.EXECUTOR_DFIP.value,
+            UserRoleEnum.EXECUTOR_RF.value,
         ):
             err = AccessDeniedException()
             err.description = (
@@ -163,5 +189,5 @@ class UserService:
         return await self.user_repo.unset_many_ssp(user_id, ssp_ids)
 
     @staticmethod
-    def _normalize_role_id(role_id: int | UserRole) -> int:
-        return role_id.value if isinstance(role_id, UserRole) else int(role_id)
+    def _normalize_role_id(role_id: int | UserRoleEnum) -> int:
+        return role_id.value if isinstance(role_id, UserRoleEnum) else int(role_id)

api/tests/integration/conftest.py

@@ -1,49 +1,81 @@
+import asyncio
+from contextlib import contextmanager
 import os
-from pathlib import Path
 
 import pytest
-from alembic import command
-from alembic.config import Config
 from fastapi.testclient import TestClient
 
-# Keep a single sqlite target for app + alembic during tests.
-TEST_DATABASE_URL = "sqlite+aiosqlite:///./app.db"
-os.environ["DATABASE_URL"] = TEST_DATABASE_URL
-os.environ["OPENBAO__SETTINGS__DATABASE_URL"] = TEST_DATABASE_URL
-os.environ["OPENBAO__SETTINGS_TEST__DATABASE_URL"] = TEST_DATABASE_URL
-os.environ["OPENBAO__SETTINGS__DEBUG"] = "true"
-os.environ["OPENBAO__SETTINGS_TEST__DEBUG"] = "true"
 
+from src.db.base import SessionLocal
+from src.db.session import get_db
 from src.main import app
 
 
-@pytest.fixture(scope="session", autouse=True)
-def migrate_db():
-    db_files = [Path("app.db"), Path("dfip_budget_planing.db"), Path("dfip_new_schema.db")]
-    for db_file in db_files:
-        if db_file.exists():
-            os.remove(db_file)
-
-    alembic_cfg = Config("alembic.ini")
-    command.upgrade(alembic_cfg, "head")
-    yield
-
-    for db_file in db_files:
-        if db_file.exists():
-            os.remove(db_file)
-
             
 @pytest.fixture
 def client():
+    db_ref = SessionLocal()
+    loop_ref = None
+
+    async def _get_db():
+        nonlocal loop_ref
+        loop_ref = asyncio.get_running_loop()
+        try:
+            yield db_ref
+            await db_ref.flush()
+        except:
+            await db_ref.rollback()
+            raise
+
+    app.dependency_overrides[get_db] = _get_db
     with TestClient(app) as test_client:
+        try:
             yield test_client
+        finally:
+            if db_ref is not None and loop_ref:
+                async def cleanup():
+                    await db_ref.rollback()
+                    await db_ref.close()
+
+                future = asyncio.run_coroutine_threadsafe(cleanup(), loop_ref)
+                future.result()
+            app.dependency_overrides.clear()
 
 
 @pytest.fixture
-def admin_tokens(client):
+def admin_password() -> str:
+    # Пароль админа берём из окружения, чтобы не хардкодить локальные отличия.
+    return os.getenv("OPENBAO__TEST_ADMIN_PASSWORD", "admin123")
+
+
+@pytest.fixture
+def isp_password() -> str:
+    # Пароль админа берём из окружения, чтобы не хардкодить локальные отличия.
+    return os.getenv("OPENBAO__TEST_EXECUTOR_PASSWORD", "admin123")
+
+
+@pytest.fixture
+def admin_tokens(client, admin_password: str):
     response = client.post(
         "/api/v1/auth/login",
-        json={"username": "admin", "password": "admin"},
+        json={"username": "admin", "password": admin_password},
+    )
+    assert response.status_code == 200
+    return response.json()
+
+
+@pytest.fixture
+def auth_headers():
+    def _build(tokens: dict) -> dict:
+        return {"Authorization": f"Bearer {tokens['access_token']}"}
+
+    return _build
+
+@pytest.fixture
+def isp_tokens(client, isp_password: str):
+    response = client.post(
+        "/api/v1/auth/login",
+        json={"username": "isp1", "password": isp_password},
     )
     assert response.status_code == 200
     return response.json()

api/tests/integration/test_audit_api_integration.py

@@ -0,0 +1,67 @@
+# import uuid
+#
+#
+# def _create_executor_and_tokens(client, admin_tokens, auth_headers) -> tuple[int, dict]:
+#     suffix = uuid.uuid4().hex[:8]
+#     username = f"audit_exec_{suffix}"
+#     password = "pass123"
+#     created = client.put(
+#         "/api/v1/users/",
+#         json={
+#             "email": f"{username}@example.com",
+#             "username": username,
+#             "password": password,
+#             "full_name": "Audit Executor",
+#             "role_id": 2,
+#         },
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert created.status_code == 200
+#     user_id = created.json()["result"]["id"]
+#
+#     login = client.post(
+#         "/api/v1/auth/login",
+#         json={"username": username, "password": password},
+#     )
+#     assert login.status_code == 200
+#     return user_id, login.json()
+
+
+def test_audit_logs_admin_smoke(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/audit-logs", headers=auth_headers(admin_tokens))
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert isinstance(payload["result"], list)
+
+
+def test_audit_logs_requires_auth(client):
+    response = client.get("/api/v1/audit-logs")
+    assert response.status_code == 403
+
+
+# Тест временно отключён: внутри создаётся пользователь.
+# def test_audit_logs_forbidden_for_non_admin(client, admin_tokens, auth_headers):
+#     user_id, executor_tokens = _create_executor_and_tokens(
+#         client, admin_tokens, auth_headers
+#     )
+#     try:
+#         response = client.get(
+#             "/api/v1/audit-logs",
+#             headers=auth_headers(executor_tokens),
+#         )
+#         assert response.status_code == 403
+#     finally:
+#         client.delete(
+#             f"/api/v1/users/{user_id}",
+#             headers=auth_headers(admin_tokens),
+#         )
+
+
+def test_audit_logs_query_validation(client, admin_tokens, auth_headers):
+    response = client.get(
+        "/api/v1/audit-logs?limit=101",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 422

api/tests/integration/test_audit_events_integration.py

@@ -0,0 +1,276 @@
+
+# # закоментированы для избежания переполнения бд
+
+
+
+# from datetime import datetime, timedelta
+# import uuid
+
+# import pytest
+
+
+# def _find_event(
+#     client,
+#     admin_tokens: dict,
+#     auth_headers,
+#     event_type: str,
+#     predicate,
+#     limit: int = 100,
+# ):
+#     response = client.get(
+#         f"/api/v1/audit-logs?event_type={event_type}&limit={limit}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200
+#     result = response.json().get("result", [])
+#     for item in result:
+#         payload = item.get("payload_json") or {}
+#         if predicate(payload):
+#             return item
+#     return None
+
+
+# def _event_count(client, admin_tokens: dict, auth_headers, event_type: str) -> int:
+#     response = client.get(
+#         f"/api/v1/audit-logs?event_type={event_type}&limit=1",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200
+#     return int(response.json().get("count") or 0)
+
+
+# def _pick_target_user_id(client, admin_tokens: dict, auth_headers) -> int:
+#     me_resp = client.get(
+#         "/api/v1/users/me",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert me_resp.status_code == 200
+#     me = me_resp.json() or {}
+#     assert me.get("id") is not None
+#     return int(me["id"])
+
+
+# def _pick_org_unit_id(client, admin_tokens: dict, auth_headers, user_id: int) -> int:
+#     forms_resp = client.get(
+#         "/api/v1/form/?limit=100",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert forms_resp.status_code == 200
+#     forms = forms_resp.json().get("result") or []
+#     candidate_ids = [f.get("org_unit_id") for f in forms if f.get("org_unit_id") is not None]
+#     assert candidate_ids
+
+#     assigned_resp = client.get(
+#         f"/api/v1/users/dfip-many-ssp/?user_id={user_id}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert assigned_resp.status_code == 200
+#     assigned = {
+#         int(item["id"])
+#         for item in (assigned_resp.json().get("result") or {}).get("ssp", [])
+#         if item.get("id") is not None
+#     }
+#     for org_unit_id in candidate_ids:
+#         if int(org_unit_id) not in assigned:
+#             return int(org_unit_id)
+#     raise AssertionError("Не найден org_unit_id, который можно прикрепить пользователю")
+
+
+# def _create_temp_user(client, admin_tokens: dict, auth_headers, role_id: int = 2) -> int:
+#     suffix = uuid.uuid4().hex[:8]
+#     username = f"audit_u_{suffix}"
+#     response = client.put(
+#         "/api/v1/users/",
+#         json={
+#             "email": f"{username}@example.com",
+#             "username": username,
+#             "password": "pass123",
+#             "full_name": "Audit User",
+#             "role_id": role_id,
+#         },
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200, response.text
+#     result = response.json().get("result") or {}
+#     return int(result["id"])
+
+
+# def _create_project(client, admin_tokens: dict, auth_headers) -> int:
+#     response = client.post(
+#         "/api/v1/projects",
+#         json={"name": f"PT_{uuid.uuid4().hex[:10]}", "year": 2026, "branch_id": 1},
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200, response.text
+#     return int(response.json()["project_id"])
+
+
+# def _add_project_line(client, admin_tokens: dict, auth_headers, project_id: int) -> int:
+#     for expense_item_id in range(1, 80):
+#         response = client.post(
+#             f"/api/v1/projects/{project_id}/report/2026/LIMIT/line",
+#             json={"expense_item_id": expense_item_id},
+#             headers=auth_headers(admin_tokens),
+#         )
+#         if response.status_code != 200:
+#             continue
+#         rows = response.json()
+#         input_row = next(
+#             (
+#                 row
+#                 for row in rows
+#                 if row.get("row_type") == "INPUT" and row.get("data", {}).get("line_id")
+#             ),
+#             None,
+#         )
+#         if input_row:
+#             return int(input_row["data"]["line_id"])
+#     raise AssertionError("Не удалось добавить строку в проектный отчёт для ROW_* тестов")
+
+
+# def _create_stage(client, admin_tokens, auth_headers, form_id: int, sheet: str) -> dict:
+#     phase_code = f"autotest_{uuid.uuid4().hex[:8]}"
+#     opens_at = datetime.utcnow().replace(microsecond=0)
+#     closes_at = opens_at + timedelta(days=2)
+#     response = client.post(
+#         f"/api/v1/stages/form/{form_id}",
+#         json={
+#             "sheet": sheet,
+#             "phase_code": phase_code,
+#             "role": "DFIP",
+#             "column_keys": ["plan.q1"],
+#             "opens_at": opens_at.isoformat() + "Z",
+#             "closes_at": closes_at.isoformat() + "Z",
+#         },
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200, response.text
+#     result = response.json().get("result") or {}
+#     assert result.get("phase_code") == phase_code
+#     return result
+
+
+# def test_audit_user_access_granted_event(client, admin_tokens, auth_headers):
+#     user_id = _pick_target_user_id(client, admin_tokens, auth_headers)
+#     org_unit_id = _pick_org_unit_id(client, admin_tokens, auth_headers, user_id)
+
+#     response = client.put(
+#         f"/api/v1/users/dfip-many-ssp/?user_id={user_id}",
+#         json={"ssp_ids": [org_unit_id]},
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200
+#     assert response.json().get("success") is True
+
+#     event = _find_event(
+#         client,
+#         admin_tokens,
+#         auth_headers,
+#         "USER_ACCESS_GRANTED",
+#         lambda payload: int(payload.get("user_id", -1)) == user_id
+#         and int(payload.get("org_unit_id", -1)) == org_unit_id,
+#     )
+#     assert event is not None
+
+
+# def test_audit_user_access_revoked_event(client, admin_tokens, auth_headers):
+#     user_id = _pick_target_user_id(client, admin_tokens, auth_headers)
+#     assigned_resp = client.get(
+#         f"/api/v1/users/dfip-many-ssp/?user_id={user_id}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert assigned_resp.status_code == 200
+#     assigned = (assigned_resp.json().get("result") or {}).get("ssp", [])
+
+#     if assigned:
+#         org_unit_id = int(assigned[0]["id"])
+#     else:
+#         org_unit_id = _pick_org_unit_id(client, admin_tokens, auth_headers, user_id)
+#         attach_resp = client.put(
+#             f"/api/v1/users/dfip-many-ssp/?user_id={user_id}",
+#             json={"ssp_ids": [org_unit_id]},
+#             headers=auth_headers(admin_tokens),
+#         )
+#         assert attach_resp.status_code == 200
+#         assert attach_resp.json().get("success") is True
+
+#     response = client.request(
+#         "DELETE",
+#         f"/api/v1/users/dfip-many-ssp/?user_id={user_id}",
+#         json={"ssp_ids": [org_unit_id]},
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200
+#     assert response.json().get("success") is True
+
+#     event = _find_event(
+#         client,
+#         admin_tokens,
+#         auth_headers,
+#         "USER_ACCESS_REVOKED",
+#         lambda payload: int(payload.get("user_id", -1)) == user_id
+#         and int(payload.get("org_unit_id", -1)) == org_unit_id,
+#     )
+#     assert event is not None
+
+
+# def test_audit_user_create_event(client, admin_tokens, auth_headers):
+#     before = _event_count(client, admin_tokens, auth_headers, "USER_CREATE")
+#     user_id = _create_temp_user(client, admin_tokens, auth_headers, role_id=2)
+#     after = _event_count(client, admin_tokens, auth_headers, "USER_CREATE")
+#     assert after > before
+
+#     delete_resp = client.delete(
+#         f"/api/v1/users/{user_id}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert delete_resp.status_code == 200
+
+
+# def test_audit_user_role_change_event(client, admin_tokens, auth_headers):
+#     user_id = _create_temp_user(client, admin_tokens, auth_headers, role_id=2)
+#     before = _event_count(client, admin_tokens, auth_headers, "USER_ROLE_CHANGE")
+
+#     update_resp = client.patch(
+#         f"/api/v1/users/{user_id}",
+#         json={"role_id": 3},
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert update_resp.status_code == 200, update_resp.text
+#     after = _event_count(client, admin_tokens, auth_headers, "USER_ROLE_CHANGE")
+#     assert after > before
+
+#     delete_resp = client.delete(
+#         f"/api/v1/users/{user_id}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert delete_resp.status_code == 200
+
+
+# def test_audit_project_create_event(client, admin_tokens, auth_headers):
+#     before = _event_count(client, admin_tokens, auth_headers, "PROJECT_CREATE")
+#     _create_project(client, admin_tokens, auth_headers)
+#     after = _event_count(client, admin_tokens, auth_headers, "PROJECT_CREATE")
+#     assert after > before
+
+
+# def test_audit_row_create_event(client, admin_tokens, auth_headers):
+#     project_id = _create_project(client, admin_tokens, auth_headers)
+#     before = _event_count(client, admin_tokens, auth_headers, "ROW_CREATE")
+#     _add_project_line(client, admin_tokens, auth_headers, project_id)
+#     after = _event_count(client, admin_tokens, auth_headers, "ROW_CREATE")
+#     assert after > before
+
+
+# def test_audit_row_delete_event(client, admin_tokens, auth_headers):
+#     project_id = _create_project(client, admin_tokens, auth_headers)
+#     line_id = _add_project_line(client, admin_tokens, auth_headers, project_id)
+#     before = _event_count(client, admin_tokens, auth_headers, "ROW_DELETE")
+
+#     delete_resp = client.delete(
+#         f"/api/v1/projects/{project_id}/report/2026/LIMIT/line/{line_id}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert delete_resp.status_code == 200, delete_resp.text
+#     after = _event_count(client, admin_tokens, auth_headers, "ROW_DELETE")
+#     assert after > before

api/tests/integration/test_auth_api_smoke.py

@@ -1,7 +1,7 @@
-def test_login_success(client):
+def test_login_success(client, admin_password):
     response = client.post(
         "/api/v1/auth/login",
-        json={"username": "admin", "password": "admin"},
+        json={"username": "admin", "password": admin_password},
     )
     assert response.status_code == 200
     data = response.json()
@@ -9,10 +9,10 @@ def test_login_success(client):
     assert "refresh_token" in data
 
 
-def test_login_invalid_password(client):
+def test_login_invalid_password(client, admin_password):
     response = client.post(
         "/api/v1/auth/login",
-        json={"username": "admin", "password": "wrong"},
+        json={"username": "admin", "password": f"{admin_password}_wrong"},
     )
     assert response.status_code == 401
 

api/tests/integration/test_db_functions_integration.py

@@ -0,0 +1,332 @@
+import uuid
+
+import pytest
+
+
+def _pick_form_and_sheet(client, admin_tokens, auth_headers) -> tuple[int, str, str | None]:
+    response = client.get("/api/v1/form/", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    forms = response.json().get("result") or []
+
+    for form in forms:
+        form_id = form.get("id")
+        form_type = form.get("form_type_code")
+        if not form_id or not form_type:
+            continue
+
+        sheets_response = client.get(
+            f"/api/v1/form/{form_id}/sheets",
+            headers=auth_headers(admin_tokens),
+        )
+        if sheets_response.status_code != 200:
+            continue
+
+        sheets = (sheets_response.json().get("result") or {}).get("sheets") or []
+        if "AHR" not in sheets:
+            continue
+
+        direction = "Support" if form_type == "FORM_1" else None
+        return int(form_id), "AHR", direction
+
+    pytest.skip("В тестовой БД не найдена форма с листом AHR")
+
+
+def _pick_form_with_sheet(
+    client, admin_tokens, auth_headers, target_sheet: str, form_type_code: str | None = None
+) -> tuple[int, str]:
+    response = client.get("/api/v1/form/", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    forms = response.json().get("result") or []
+    for form in forms:
+        form_id = form.get("id")
+        if not form_id:
+            continue
+        if form_type_code and form.get("form_type_code") != form_type_code:
+            continue
+        sheets_response = client.get(
+            f"/api/v1/form/{form_id}/sheets",
+            headers=auth_headers(admin_tokens),
+        )
+        if sheets_response.status_code != 200:
+            continue
+        sheets = (sheets_response.json().get("result") or {}).get("sheets") or []
+        if target_sheet in sheets:
+            return int(form_id), target_sheet
+    pytest.skip(f"Не найдена форма с листом {target_sheet}")
+
+
+def _pick_input_line_id(
+    client, admin_tokens, auth_headers, form_id: int, sheet: str, direction: str | None
+) -> int:
+    url = f"/api/v1/form/{form_id}/sheet/{sheet}"
+    params = []
+    if direction:
+        params.append(f"direction={direction}")
+    if params:
+        url = f"{url}?{'&'.join(params)}"
+
+    response = client.get(url, headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    rows = response.json().get("result") or []
+    for row in rows:
+        data = row.get("data") or {}
+        if row.get("row_type") == "INPUT" and data.get("line_id"):
+            return int(data["line_id"])
+
+    pytest.skip("Не найден INPUT line_id для проверки upd_form_cell")
+
+
+def test_backend_calls_v_form_view_via_sheet_endpoint(client, admin_tokens, auth_headers):
+    form_id, sheet, direction = _pick_form_and_sheet(client, admin_tokens, auth_headers)
+    url = f"/api/v1/form/{form_id}/sheet/{sheet}"
+    if direction:
+        url = f"{url}?direction={direction}"
+
+    response = client.get(url, headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    payload = response.json()
+    assert isinstance(payload.get("result"), list)
+    if payload["result"]:
+        first_row = payload["result"][0]
+        assert "row_type" in first_row
+        assert "data" in first_row
+
+
+def test_backend_calls_upd_form_cell_and_maps_sql_validation_error(
+    client, admin_tokens, auth_headers
+):
+    form_id, sheet, direction = _pick_form_and_sheet(client, admin_tokens, auth_headers)
+    line_id = _pick_input_line_id(
+        client, admin_tokens, auth_headers, form_id, sheet, direction
+    )
+
+    url = f"/api/v1/form/{form_id}/sheet/{sheet}/cell"
+    if direction:
+        url = f"{url}?direction={direction}"
+
+    response = client.patch(
+        url,
+        json={"line_id": line_id, "column": "bad.scope", "value": 1},
+        headers=auth_headers(admin_tokens),
+    )
+
+    # SQL-функция отдает prefixed validation error.
+    assert response.status_code in (400, 422)
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+    assert isinstance(payload["message"], str)
+
+
+def test_backend_calls_form3_add_project_and_add_line_functions(
+    client, admin_tokens, auth_headers
+):
+    create = client.post(
+        "/api/v1/projects",
+        json={"name": f"ITEST_DB_FUNC_{uuid.uuid4().hex[:6]}", "year": 2026, "branch_id": 1},
+        headers=auth_headers(admin_tokens),
+    )
+    assert create.status_code == 200
+    project_payload = create.json()
+    assert "project_id" in project_payload
+    assert "limit_report_id" in project_payload
+    assert "current_expenses_report_id" in project_payload
+
+    project_id = int(project_payload["project_id"])
+    add_line = client.post(
+        f"/api/v1/projects/{project_id}/report/2026/LIMIT/line",
+        json={"expense_item_id": 1},
+        headers=auth_headers(admin_tokens),
+    )
+    assert add_line.status_code == 200
+    rows = add_line.json()
+    assert isinstance(rows, list)
+
+
+def test_forms_validation_invalid_sections_returns_400(client, admin_tokens, auth_headers):
+    form_id, sheet = _pick_form_with_sheet(client, admin_tokens, auth_headers, "AHR")
+    response = client.get(
+        f"/api/v1/form/{form_id}/sheet/{sheet}?sections=bad_section",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 400
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_forms_validation_empty_sections_csv_is_ignored(client, admin_tokens, auth_headers):
+    form_id, sheet, direction = _pick_form_and_sheet(client, admin_tokens, auth_headers)
+    url = f"/api/v1/form/{form_id}/sheet/{sheet}?sections= , , "
+    if direction:
+        url += f"&direction={direction}"
+    response = client.get(url, headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    payload = response.json()
+    assert isinstance(payload.get("result"), list)
+
+
+def test_forms_validation_direction_required_for_form1_ahr(
+    client, admin_tokens, auth_headers
+):
+    form_id, sheet = _pick_form_with_sheet(
+        client, admin_tokens, auth_headers, "AHR", form_type_code="FORM_1"
+    )
+    response = client.get(
+        f"/api/v1/form/{form_id}/sheet/{sheet}",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 400
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+    assert "direction" in payload["message"].lower()
+
+
+def test_forms_validation_direction_case_sensitive(client, admin_tokens, auth_headers):
+    form_id, sheet = _pick_form_with_sheet(
+        client, admin_tokens, auth_headers, "AHR", form_type_code="FORM_1"
+    )
+    response = client.get(
+        f"/api/v1/form/{form_id}/sheet/{sheet}?direction=support",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 422
+
+
+def test_forms_validation_direction_forbidden_on_non_form1(
+    client, admin_tokens, auth_headers
+):
+    form_id, sheet = _pick_form_with_sheet(
+        client, admin_tokens, auth_headers, "AHR", form_type_code="FORM_2"
+    )
+    response = client.get(
+        f"/api/v1/form/{form_id}/sheet/{sheet}?direction=Support",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 400
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+    assert "direction" in payload["message"].lower()
+
+
+def test_form3_validation_invalid_sections_returns_400(client, admin_tokens, auth_headers):
+    create = client.post(
+        "/api/v1/projects",
+        json={"name": f"ITEST_F3_SECT_{uuid.uuid4().hex[:6]}", "year": 2026, "branch_id": 1},
+        headers=auth_headers(admin_tokens),
+    )
+    assert create.status_code == 200
+    project_id = int(create.json()["project_id"])
+    response = client.get(
+        f"/api/v1/projects/{project_id}/report/2026/LIMIT?sections=q1,q5",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 400
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_form3_validation_empty_sections_csv_is_ignored(client, admin_tokens, auth_headers):
+    create = client.post(
+        "/api/v1/projects",
+        json={"name": f"ITEST_F3_EMPTY_{uuid.uuid4().hex[:6]}", "year": 2026, "branch_id": 1},
+        headers=auth_headers(admin_tokens),
+    )
+    assert create.status_code == 200
+    project_id = int(create.json()["project_id"])
+    response = client.get(
+        f"/api/v1/projects/{project_id}/report/2026/LIMIT?sections= , , ",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    assert isinstance(response.json().get("result"), list)
+
+
+def test_form3_validation_duplicate_sections_is_allowed(client, admin_tokens, auth_headers):
+    create = client.post(
+        "/api/v1/projects",
+        json={"name": f"ITEST_F3_DUP_{uuid.uuid4().hex[:6]}", "year": 2026, "branch_id": 1},
+        headers=auth_headers(admin_tokens),
+    )
+    assert create.status_code == 200
+    project_id = int(create.json()["project_id"])
+    response = client.get(
+        f"/api/v1/projects/{project_id}/report/2026/LIMIT?sections=q1,q1",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    assert isinstance(response.json().get("result"), list)
+
+
+def test_form3_add_project_invalid_name_returns_422(client, admin_tokens, auth_headers):
+    # Пробел запрещён regex-правилом AddProjectBody.
+    response = client.post(
+        "/api/v1/projects",
+        json={"name": "INVALID NAME", "year": 2026, "branch_id": 1},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 422
+
+
+def test_health_and_ready_endpoints(client):
+    healthz = client.get("/healthz")
+    assert healthz.status_code == 200
+    health_payload = healthz.json()
+    assert health_payload.get("status") == "ok"
+
+    readyz = client.get("/readyz")
+    assert readyz.status_code in (200, 503)
+    ready_payload = readyz.json()
+    assert "status" in ready_payload
+    assert "db_status" in ready_payload
+    assert "mv_expense_item_tree" in ready_payload
+
+
+# Тест временно отключён: внутри создаётся пользователь.
+# def test_admin_refresh_tree_requires_admin_role(client, admin_tokens, auth_headers):
+#     admin_resp = client.post(
+#         "/api/v1/admin/refresh-tree",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert admin_resp.status_code in (200, 503)
+#
+#     uname = f"itest_non_admin_{uuid.uuid4().hex[:6]}"
+#     create_user = client.put(
+#         "/api/v1/users/",
+#         json={
+#             "email": f"{uname}@example.com",
+#             "username": uname,
+#             "password": "pass123",
+#             "full_name": "Integration User",
+#             "role_id": 2,
+#         },
+#         headers=auth_headers(admin_tokens),
+#     )
+#     if create_user.status_code != 200:
+#         pytest.skip("Не удалось создать non-admin пользователя в текущей БД")
+#
+#     login_resp = client.post("/api/v1/auth/login", json={"username": uname, "password": "pass123"})
+#     if login_resp.status_code != 200:
+#         pytest.skip("Не удалось залогинить non-admin пользователя в текущей БД")
+#     user_tokens = login_resp.json()
+#
+#     non_admin_resp = client.post(
+#         "/api/v1/admin/refresh-tree",
+#         headers=auth_headers(user_tokens),
+#     )
+#     assert non_admin_resp.status_code == 403
+#
+#     # Что бы не было переполнения бд
+#     deleted = client.delete(
+#         f"/api/v1/users/{create_user.json()['result']['id']}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert deleted.status_code == 200
+
+
+def test_admin_refresh_tree_requires_auth(client):
+    response = client.post("/api/v1/admin/refresh-tree")
+    assert response.status_code in (401, 403)

api/tests/integration/test_export_projects_integration.py

@@ -0,0 +1,38 @@
+import pytest
+
+
+def _get_any_project_report(client, admin_tokens, auth_headers) -> tuple[int, int, str]:
+    list_response = client.get(
+        "/api/v1/projects?limit=50",
+        headers=auth_headers(admin_tokens),
+    )
+    assert list_response.status_code == 200
+    projects = list_response.json().get("result") or []
+    for project in projects:
+        project_id = int(project["id"])
+        details_response = client.get(
+            f"/api/v1/projects/{project_id}",
+            headers=auth_headers(admin_tokens),
+        )
+        if details_response.status_code != 200:
+            continue
+        reports = (details_response.json().get("result") or {}).get("reports") or []
+        if reports:
+            report = reports[0]
+            return project_id, int(report["year"]), str(report["report_type"])
+    pytest.skip("Не найден проект FORM_3 с отчетами для smoke-экспорта")
+
+
+def test_export_project_report_smoke(client, admin_tokens, auth_headers):
+    project_id, report_year, report_type = _get_any_project_report(client, admin_tokens, auth_headers)
+
+    response = client.get(
+        f"/api/v1/export/project/{project_id}/report/{report_year}/{report_type}",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == (
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    )
+    assert "attachment; filename*=UTF-8''" in response.headers["content-disposition"]
+    assert len(response.content) > 0

api/tests/integration/test_form_phases_api_smoke.py

@@ -0,0 +1,140 @@
+import pytest
+
+
+def _auth_headers(tokens: dict) -> dict:
+    return {"Authorization": f"Bearer {tokens['access_token']}"}
+
+
+def test_form_phases_list_smoke(client, admin_tokens):
+    response = client.get(
+        "/api/v1/stages/form/1", headers=_auth_headers(admin_tokens)
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert "count" in payload
+    assert isinstance(payload["result"], list)
+
+
+def test_form_phases_list_filter_smoke(client, admin_tokens):
+
+    response = client.get(
+        "/api/v1/stages/form/1", headers=_auth_headers(admin_tokens)
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert "count" in payload
+    count = payload["count"]
+
+    response = client.get(
+        "/api/v1/stages/form/1?sheet=AHR&phase_code=test", headers=_auth_headers(admin_tokens)
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert "count" in payload
+    assert payload["count"] <= count
+
+
+def test_form_phases_create_forbidden(client, isp_tokens):
+    response = client.post(
+        "/api/v1/stages/form/1",
+        json={
+            "sheet": "AHR",
+            "phase_code": "new_phase",
+            "role": "DFIP",
+            "column_keys": ["plan.q1"],
+            "opens_at": "2026-01-01T00:00:00Z",
+            "closes_at": "2026-12-31T00:00:00Z",
+        },
+        headers=_auth_headers(isp_tokens),
+    )
+    assert response.status_code == 403
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_form_phases_update_forbidden(client, isp_tokens):
+    response = client.patch(
+        "/api/v1/stages/form/1/AHR/test",
+        json={
+            "role": "DFIP",
+            "column_keys": ["plan.q1"],
+            "opens_at": "2026-01-01T00:00:00Z",
+            "closes_at": "2026-12-31T00:00:00Z",
+        },
+        headers=_auth_headers(isp_tokens),
+    )
+    assert response.status_code == 403
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_form_phases_delete_forbidden(client, isp_tokens):
+    response = client.delete(
+        "/api/v1/stages/form/1/AHR/test",
+        headers=_auth_headers(isp_tokens),
+    )
+    assert response.status_code == 403
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_form_phases_create(client, admin_tokens):
+    body = {
+        "budget_form_id": 1,
+        "sheet": "AHR",
+        "phase_code": "new_phase",
+        "role": "DFIP",
+        "column_keys": ["plan.q1"],
+        "opens_at": "2026-01-01T00:00:00Z",
+        "closes_at": "2026-12-31T00:00:00Z",
+    }
+    response = client.post(
+        "/api/v1/stages/form/1",
+        json=body,
+        headers=_auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert "success" in payload
+    assert payload["success"]
+    assert "result" in payload
+    assert isinstance(payload["result"], dict)
+    assert payload["result"] == body
+
+
+def test_form_phases_update(client, admin_tokens):
+    body = {
+        "budget_form_id": 1,
+        "sheet": "AHR",
+        "phase_code": "test",
+        "role": "EXECUTOR_RF",
+        "column_keys": ["plan.q1"],
+        "opens_at": "2026-01-01T00:00:00Z",
+        "closes_at": "2026-12-31T00:00:00Z",
+    }
+    response = client.patch(
+        "/api/v1/stages/form/1/AHR/test",
+        json=body,
+        headers=_auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    payload = response.json()
+
+    assert "success" in payload
+    assert payload["success"]
+    assert "result" in payload
+    assert isinstance(payload["result"], dict)
+    assert payload["result"] == body
+
+
+def test_form_phases_delete(client, admin_tokens):
+    response = client.delete(
+        "/api/v1/stages/form/1/AHR/test",
+        headers=_auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+

api/tests/integration/test_forms_api_smoke.py

@@ -0,0 +1,137 @@
+import pytest
+
+
+def test_forms_list_smoke(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/form/", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert "count" in payload
+    assert isinstance(payload["result"], list)
+
+
+def test_form_smoke(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/form/1", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert isinstance(payload["result"], dict)
+
+
+def test_forms_sheets_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.get(
+        "/api/v1/form/999/sheets", headers=auth_headers(admin_tokens)
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+    assert isinstance(payload["message"], str)
+
+
+def test_forms_sheet_get_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.get(
+        "/api/v1/form/999/sheet/AHR", headers=auth_headers(admin_tokens)
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_forms_cell_update_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.patch(
+        "/api/v1/form/999/sheet/AHR/cell",
+        json={"line_id": 1, "column": "q1.m1", "value": 100},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_forms_cell_update(client, admin_tokens, auth_headers):
+    response = client.patch(
+        "/api/v1/form/1/sheet/AHR/cell?direction=Support&sections=plan,contract_summary",
+        json={
+            "line_id": 1,
+            "column": "plan.q1",
+            "value": 225
+        },
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "result" in payload
+
+
+def test_forms_cells_update_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.patch(
+        "/api/v1/form/999/sheet/AHR/cells",
+        json={"changes": [{"line_id": 1, "column": "q1.m1", "value": 100}]},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_forms_cells_update(client, admin_tokens, auth_headers):
+    response = client.patch(
+        "/api/v1/form/1/sheet/AHR/cells?direction=Support&sections=plan,contract_summary",
+        json={
+            "changes": [
+                {
+                    "line_id": 1,
+                    "column": "plan.q1",
+                    "value": 226
+                }
+            ],
+        },
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "result" in payload
+
+
+def test_forms_add_line_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.post(
+        "/api/v1/form/999/sheet/AHR/line",
+        json={},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+
+
+def test_forms_add_line(client, admin_tokens, auth_headers):
+    response = client.post(
+        "/api/v1/form/1/sheet/AHR/line?direction=Support&sections=plan,contract_summary",
+        json={
+            "expense_item_id": 120,
+            "direction": "Support"
+        },
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "result" in payload
+
+
+def test_forms_delete_line_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.delete(
+        "/api/v1/form/999/sheet/AHR/line/1",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload

api/tests/integration/test_org_units_integration.py

@@ -0,0 +1,111 @@
+import pydantic_core
+import pytest
+
+
+def test_org_units_list_smoke(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/org-unit/", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert "count" in payload
+    assert isinstance(payload["result"], list)
+
+
+def test_org_units_list_with_users_count(client, admin_tokens, auth_headers):
+    response = client.get(
+        "/api/v1/org-unit/?load_users_count=true",
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert isinstance(payload["result"], list)
+    if payload["result"]:
+        assert "users_count" in payload["result"][0]
+
+
+def test_org_units_get(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/org-unit/1", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert payload["result"]["id"] == 1
+
+
+def test_org_units_get_not_found(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/org-unit/99999", headers=auth_headers(admin_tokens))
+    assert response.status_code == 404
+
+
+# def test_org_units_create_smoke(client, admin_tokens, auth_headers):
+#     suffix = uuid.uuid4().hex[:8]
+#     title = f"Test Org {suffix}"
+#     response = client.post(
+#         "/api/v1/org-unit/",
+#         json={"title": title, "is_ssp": True},
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200
+#     payload = response.json()
+#     assert payload["result"]["title"] == title
+#     assert payload["result"]["is_ssp"] is True
+
+
+# def test_org_units_create_non_ssp(client, admin_tokens, auth_headers):
+#     suffix = uuid.uuid4().hex[:8]
+#     title = f"Test RF {suffix}"
+#     response = client.post(
+#         "/api/v1/org-unit/",
+#         json={"title": title, "is_ssp": False},
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200
+#     payload = response.json()
+#     assert payload["result"]["title"] == title
+#     assert payload["result"]["is_ssp"] is False
+
+
+# def test_org_units_update_smoke(client, admin_tokens, auth_headers):
+#     new_title = f"Updated_{uuid.uuid4().hex[:8]}"
+#     response = client.patch(
+#         "/api/v1/org-unit/1",
+#         json={"title": new_title},
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert response.status_code == 200
+#     payload = response.json()
+#     assert payload["result"]["title"] == new_title
+#     assert payload["result"]["id"] == 1
+
+
+def test_org_units_update_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.patch(
+        "/api/v1/org-unit/99999",
+        json={"title": "No Matter"},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "code" in payload
+    assert "message" in payload
+
+
+def test_org_units_delete_not_found_error_shape(client, admin_tokens, auth_headers):
+    response = client.delete(
+        "/api/v1/org-unit/99999", headers=auth_headers(admin_tokens)
+    )
+    assert response.status_code == 404
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "code" in payload
+    assert "message" in payload
+
+
+def test_org_units_access_denied_for_non_admin(client, isp_tokens, auth_headers):
+    response = client.get("/api/v1/org-unit/", headers=auth_headers(isp_tokens))
+    assert response.status_code == 403
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "code" in payload
+    assert "message" in payload

api/tests/integration/test_projects_api_smoke.py

@@ -0,0 +1,119 @@
+import uuid
+
+import pytest
+
+
+def test_projects_list_smoke(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/projects", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    payload = response.json()
+    assert "result" in payload
+    assert "count" in payload
+    assert isinstance(payload["result"], list)
+
+
+def _create_project(client, admin_tokens, auth_headers) -> tuple[int, str]:
+    name = f"PT_{uuid.uuid4().hex[:10]}"
+    response = client.post(
+        "/api/v1/projects",
+        json={"name": name, "year": 2026, "branch_id": 1},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    return payload["project_id"], name
+
+
+def _add_line(client, admin_tokens, auth_headers, project_id: int) -> int:
+    for expense_item_id in range(1, 80):
+        response = client.post(
+            f"/api/v1/projects/{project_id}/report/2026/LIMIT/line",
+            json={"expense_item_id": expense_item_id},
+            headers=auth_headers(admin_tokens),
+        )
+        if response.status_code != 200:
+            continue
+        rows = response.json()
+        input_row = next(
+            (
+                row
+                for row in rows
+                if row.get("row_type") == "INPUT" and row.get("data", {}).get("line_id")
+            ),
+            None,
+        )
+        if input_row:
+            return int(input_row["data"]["line_id"])
+
+    pytest.skip("Не удалось подобрать expense_item_id для add_form3_line в текущей БД")
+
+
+def test_projects_write_smoke(client, admin_tokens, auth_headers):
+    project_id, name = _create_project(client, admin_tokens, auth_headers)
+
+    upd_project_response = client.patch(
+        f"/api/v1/project/{project_id}",
+        json={"column": "name", "value": f"{name}_U"},
+        headers=auth_headers(admin_tokens),
+    )
+    assert upd_project_response.status_code == 200
+
+    line_id = _add_line(client, admin_tokens, auth_headers, project_id)
+
+    upd_cell_response = client.patch(
+        f"/api/v1/projects/{project_id}/report/2026/LIMIT/cell",
+        json={"line_id": line_id, "column": "q1.m1", "value": 100},
+        headers=auth_headers(admin_tokens),
+    )
+    assert upd_cell_response.status_code == 200
+    assert isinstance(upd_cell_response.json(), list)
+
+    upd_cells_response = client.patch(
+        f"/api/v1/projects/{project_id}/report/2026/LIMIT/cells",
+        json={
+            "changes": [
+                {"line_id": line_id, "column": "q1.m2", "value": 200},
+                {"line_id": line_id, "column": "q1.m3", "value": 300},
+            ]
+        },
+        headers=auth_headers(admin_tokens),
+    )
+    assert upd_cells_response.status_code == 200
+    assert isinstance(upd_cells_response.json(), list)
+
+    del_line_response = client.delete(
+        f"/api/v1/projects/{project_id}/report/2026/LIMIT/line/{line_id}",
+        headers=auth_headers(admin_tokens),
+    )
+    assert del_line_response.status_code == 200
+
+
+def test_projects_write_invalid_report_type_error_shape(client, admin_tokens, auth_headers):
+    project_id, _ = _create_project(client, admin_tokens, auth_headers)
+    line_id = _add_line(client, admin_tokens, auth_headers, project_id)
+
+    response = client.patch(
+        f"/api/v1/projects/{project_id}/report/2026/BAD_TYPE/cell",
+        json={"line_id": line_id, "column": "q1.m1", "value": 100},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 400
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert "message" in payload
+    assert isinstance(payload["message"], str)
+
+
+def test_projects_write_report_not_found_error_shape(client, admin_tokens, auth_headers):
+    project_id, _ = _create_project(client, admin_tokens, auth_headers)
+    line_id = _add_line(client, admin_tokens, auth_headers, project_id)
+
+    response = client.patch(
+        f"/api/v1/projects/{project_id}/report/2099/LIMIT/cell",
+        json={"line_id": line_id, "column": "q1.m1", "value": 100},
+        headers=auth_headers(admin_tokens),
+    )
+    assert response.status_code == 400
+    payload = response.json()
+    assert isinstance(payload, dict)
+    assert payload.get("message") == "Отчёт не найден"

api/tests/integration/test_users_api_smoke.py

@@ -1,30 +1,85 @@
-def _auth_headers(tokens: dict) -> dict:
-    return {"Authorization": f"Bearer {tokens['access_token']}"}
+import uuid
 
 
-def test_users_me(client, admin_tokens):
-    response = client.get("/api/v1/users/me", headers=_auth_headers(admin_tokens))
+def test_users_me(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/users/me", headers=auth_headers(admin_tokens))
     assert response.status_code == 200
     assert response.json()["username"] == "admin"
 
 
-def test_users_create_and_list(client, admin_tokens):
-    create_payload = {
-        "email": "user1@example.com",
-        "username": "user1",
-        "password": "pass123",
-        "full_name": "User One",
-        "role_id": 2,
-    }
-    created = client.put(
-        "/api/v1/users/",
-        json=create_payload,
-        headers=_auth_headers(admin_tokens),
-    )
-    assert created.status_code == 200
+def test_users_list(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/users/", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    result = response.json()
+    assert "result" in result
+    assert isinstance(result["result"], list)
 
-    listed = client.get("/api/v1/users/", headers=_auth_headers(admin_tokens))
-    assert listed.status_code == 200
-    usernames = [row["username"] for row in listed.json()["result"]]
-    assert "admin" in usernames
-    assert "user1" in usernames
+
+def test_users_org_list(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/users/?load_orgs=true", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    result = response.json()
+    assert "result" in result
+    assert isinstance(result["result"], list)
+    assert len(result["result"]) > 0
+    assert "org_units" in result["result"][0]
+    assert len(result["result"][0]["org_units"]) > 0
+
+
+def test_users_get(client, admin_tokens, auth_headers):
+
+    response = client.get("/api/v1/users/me", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    user = response.json()
+    assert "id" in user
+    user_id = user["id"]
+
+    response = client.get(f"/api/v1/users/{user_id}", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+
+
+def test_user_get_org_list(client, admin_tokens, auth_headers):
+    response = client.get("/api/v1/users/me", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    user = response.json()
+    assert "id" in user
+    user_id = user["id"]
+
+    response = client.get(f"/api/v1/users/{user_id}?load_orgs=true", headers=auth_headers(admin_tokens))
+    assert response.status_code == 200
+    result = response.json()
+    
+    assert "org_units" in result
+    assert len(result["org_units"]) > 0
+
+# Задокуменировано что бы не было переполнения бд, так как юзер удаляется только логически
+# def test_users_create_smoke(client, admin_tokens, auth_headers):
+#     suffix = uuid.uuid4().hex[:8]
+#     username = f"user_{suffix}"
+#     # create_payload = {
+#     #     "email": f"{username}@example.com",
+#     #     "username": username,
+#     #     "password": "pass123",
+#     #     "full_name": "User One",
+#     #     "role_id": 2,
+#     # }
+#     created = client.put(
+#         "/api/v1/users/",
+#         json={
+#             "email": f"{username}@example.com",
+#             "username": username,
+#             "password": "pass123",
+#             "full_name": "User One",
+#             "role_id": 2,
+#         },
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert created.status_code == 200
+#     assert created.json()["result"]["username"] == username
+
+#     # Что бы не было переполнения бд
+#     deleted = client.delete(
+#         f"/api/v1/users/{created.json()['result']['id']}",
+#         headers=auth_headers(admin_tokens),
+#     )
+#     assert deleted.status_code == 200

api/tests/unit/test_auditlog_repository.py

@@ -0,0 +1,78 @@
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.repository.auditlog_repository import AuditLogRepository
+
+
+def _result_with_scalars(items):
+    result = MagicMock()
+    scalars = MagicMock()
+    scalars.first.return_value = items[0] if items else None
+    scalars.all.return_value = items
+    result.scalars.return_value = scalars
+    return result
+
+
+def _result_with_scalar_one(value):
+    result = MagicMock()
+    result.scalar_one.return_value = value
+    return result
+
+
+@pytest.fixture
+def mock_db():
+    return AsyncMock(spec=AsyncSession)
+
+
+@pytest.fixture
+def repository(mock_db):
+    return AuditLogRepository(mock_db)
+
+
+@pytest.mark.asyncio
+async def test_get_returns_audit_log(repository, mock_db):
+    row = MagicMock(id=10, user_id=1, event_type="WRITE")
+    mock_db.execute.return_value = _result_with_scalars([row])
+
+    result = await repository.get(10)
+
+    assert result is row
+    mock_db.execute.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_get_returns_none_for_missing_id(repository, mock_db):
+    mock_db.execute.return_value = _result_with_scalars([])
+
+    result = await repository.get(999999)
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_get_all_applies_filters(repository, mock_db):
+    row = MagicMock(id=11, user_id=2, org_unit_id=7, event_type="UPDATE")
+    mock_db.execute.side_effect = [
+        _result_with_scalars([row]),
+        _result_with_scalar_one(1),
+    ]
+
+    result, count = await repository.get_all(
+        limit=10,
+        offset=5,
+        user_id=2,
+        org_unit_id=7,
+        task_id=3,
+        form_id=4,
+        event_type="UPDATE",
+        date_from=datetime(2026, 1, 1, tzinfo=timezone.utc),
+        date_to=datetime(2026, 12, 31, tzinfo=timezone.utc),
+    )
+
+    assert result == [row]
+    assert count == 1
+    assert mock_db.execute.await_count == 2
+

api/tests/unit/test_auditlog_service.py

@@ -0,0 +1,91 @@
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from src.core.errors import AccessDeniedException
+from src.db.models.role import UserRoleEnum
+from src.services.auditlog_service import AuditLogService
+
+
+@pytest.fixture
+def service_with_mock_repo(monkeypatch):
+    mock_repo = MagicMock()
+    mock_repo.get = AsyncMock()
+    mock_repo.get_all = AsyncMock()
+
+    repo_cls = MagicMock(return_value=mock_repo)
+    monkeypatch.setattr("src.services.auditlog_service.AuditLogRepository", repo_cls)
+
+    service = AuditLogService(AsyncMock())
+    return service, mock_repo
+
+
+@pytest.fixture
+def admin_user():
+    return SimpleNamespace(
+        id=1,
+        role_id=UserRoleEnum.ADMIN.value,
+        email="admin@example.com",
+    )
+
+
+@pytest.fixture
+def non_admin_user():
+    return SimpleNamespace(
+        id=2,
+        role_id=UserRoleEnum.EXECUTOR_DFIP.value,
+        email="executor@example.com",
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_all_allowed_for_admin(service_with_mock_repo, admin_user):
+    service, mock_repo = service_with_mock_repo
+    mock_row = SimpleNamespace(id=10)
+    mock_repo.get_all.return_value = [mock_row]
+
+    result = await service.get_all(admin_user, org_unit_id=77, event_type="form")
+
+    assert result == [mock_row]
+    mock_repo.get_all.assert_awaited_once_with(
+        limit=None,
+        offset=None,
+        user_id=None,
+        org_unit_id=77,
+        task_id=None,
+        form_id=None,
+        event_type="form",
+        date_from=None,
+        date_to=None,
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_all_denied_for_non_admin(service_with_mock_repo, non_admin_user):
+    service, mock_repo = service_with_mock_repo
+
+    with pytest.raises(AccessDeniedException):
+        await service.get_all(non_admin_user)
+
+    mock_repo.get_all.assert_not_called()
+
+
+def test_orm_log_to_response_maps_entity_and_entity_id(service_with_mock_repo):
+    service, _ = service_with_mock_repo
+    log = SimpleNamespace(
+        id=55,
+        user_id=7,
+        event="UPDATE",
+        event_type="fallback_entity",
+        event_dt="2026-05-19T12:00:00Z",
+        event_data={"entity_type": "form_line", "entity_id": "42", "x": 1},
+        user=None,
+    )
+
+    dto = service.orm_log_to_response(log)
+
+    assert dto.entity == "form_line"
+    assert dto.entity_id == 42
+    assert dto.action == "UPDATE"
+    assert dto.user_id == 7

api/tests/unit/test_exception_handlers.py

@@ -0,0 +1,155 @@
+from fastapi import HTTPException, status
+from sqlalchemy.exc import IntegrityError, OperationalError, SQLAlchemyError
+
+from src.core.exception_handlers import (
+    _error_payload,
+    map_http_exception,
+    map_sqlalchemy_error,
+)
+
+
+def test_map_sqlalchemy_error_unique_conflict():
+    exc = IntegrityError(
+        statement="INSERT INTO users ...",
+        params={},
+        orig=Exception("duplicate key value violates unique constraint users_username_key"),
+    )
+
+    status_code, code, message, field = map_sqlalchemy_error(exc)
+
+    assert status_code == status.HTTP_409_CONFLICT
+    assert code == "conflict"
+    assert "duplicate key value" in message
+    assert field is None
+
+
+def test_map_sqlalchemy_error_check_constraint_is_400():
+    exc = IntegrityError(
+        statement="UPDATE v3.project ...",
+        params={},
+        orig=Exception("new row for relation violates check constraint chk_v3_project_name"),
+    )
+
+    status_code, code, message, field = map_sqlalchemy_error(exc)
+
+    assert status_code == status.HTTP_400_BAD_REQUEST
+    assert code == "db_error"
+    assert "violates check constraint" in message
+    assert field is None
+
+
+def test_map_sqlalchemy_error_validation_prefix():
+    exc = SQLAlchemyError()
+    exc.orig = Exception("unknown_column: q5.plan")
+
+    status_code, code, message, field = map_sqlalchemy_error(exc)
+
+    assert status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+    assert code == "unknown_column"
+    assert message == "unknown_column: q5.plan"
+    assert field == "q5.plan"
+
+
+def test_map_sqlalchemy_error_not_found():
+    exc = SQLAlchemyError()
+    exc.orig = Exception("budget_form #99 не существует")
+
+    status_code, code, message, field = map_sqlalchemy_error(exc)
+
+    assert status_code == status.HTTP_404_NOT_FOUND
+    assert code == "not_found"
+    assert "не существует" in message
+    assert field is None
+
+
+def test_map_sqlalchemy_error_role_window_prefixes():
+    role_exc = SQLAlchemyError()
+    role_exc.orig = Exception("role_not_allowed: q1.m1")
+    status_code, code, message, field = map_sqlalchemy_error(role_exc)
+    assert status_code == status.HTTP_403_FORBIDDEN
+    assert code == "access_denied"
+    assert message == "role_not_allowed: q1.m1"
+    assert field is None
+
+    window_exc = SQLAlchemyError()
+    window_exc.orig = Exception("window_closed: q1.m1 (closed 2026-05-01T00:00:00Z)")
+    status_code, code, message, field = map_sqlalchemy_error(window_exc)
+    assert status_code == status.HTTP_403_FORBIDDEN
+    assert code == "access_denied"
+    assert message.startswith("window_closed:")
+    assert field is None
+
+
+def test_map_sqlalchemy_error_operational():
+    exc = OperationalError(
+        statement="SELECT 1",
+        params={},
+        orig=Exception("connection refused"),
+    )
+
+    status_code, code, message, field = map_sqlalchemy_error(exc)
+
+    assert status_code == status.HTTP_503_SERVICE_UNAVAILABLE
+    assert code == "db_unavailable"
+    assert message == "Database unavailable"
+    assert field is None
+
+
+def test_error_payload_matches_spec_shape():
+    payload = _error_payload("unknown_column", "unknown_column: q5.plan", "q5.plan")
+
+    assert payload == {
+        "code": "unknown_column",
+        "field": "q5.plan",
+        "message": "unknown_column: q5.plan",
+    }
+
+
+def test_map_http_exception_validation_prefix():
+    exc = HTTPException(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        detail="unknown_column: q5.plan",
+    )
+
+    status_code, code, message, field = map_http_exception(exc)
+
+    assert status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+    assert code == status.HTTP_422_UNPROCESSABLE_ENTITY
+    assert message == "unknown_column: q5.plan"
+    assert field is None
+
+
+def test_map_http_exception_from_structured_detail():
+    exc = HTTPException(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        detail={"code": "validation_error", "message": "bad input", "field": "username"},
+    )
+
+    status_code, code, message, field = map_http_exception(exc)
+
+    assert status_code == status.HTTP_400_BAD_REQUEST
+    assert code == "validation_error"
+    assert message == "bad input"
+    assert field == "username"
+
+
+def test_map_http_exception_unauthorized():
+    exc = HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Недействительный токен")
+
+    status_code, code, message, field = map_http_exception(exc)
+
+    assert status_code == status.HTTP_401_UNAUTHORIZED
+    assert code == status.HTTP_401_UNAUTHORIZED
+    assert message == "Недействительный токен"
+    assert field is None
+
+
+def test_map_http_exception_not_found_maps_code_from_status():
+    exc = HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="not found")
+
+    status_code, code, message, field = map_http_exception(exc)
+
+    assert status_code == status.HTTP_404_NOT_FOUND
+    assert code == status.HTTP_404_NOT_FOUND
+    assert message == "not found"
+    assert field is None

api/tests/unit/test_exception_handlers_http_shape.py

@@ -0,0 +1,68 @@
+from fastapi import FastAPI, HTTPException, status
+from fastapi.testclient import TestClient
+from sqlalchemy.exc import SQLAlchemyError
+
+from src.core.exception_handlers import register_exception_handlers
+
+
+def _make_app() -> FastAPI:
+    app = FastAPI()
+    register_exception_handlers(app)
+
+    @app.get("/http-401")
+    async def http_401():
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Недействительный токен",
+        )
+
+    @app.get("/http-422-prefixed")
+    async def http_422_prefixed():
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="unknown_column: q5.plan",
+        )
+
+    @app.get("/sql-error")
+    async def sql_error():
+        exc = SQLAlchemyError()
+        exc.orig = Exception("budget_form #99 не существует")
+        raise exc
+
+    return app
+
+
+def test_http_exception_returns_structured_payload():
+    client = TestClient(_make_app())
+    response = client.get("/http-401")
+
+    assert response.status_code == status.HTTP_401_UNAUTHORIZED
+    assert response.json() == {
+        "code": status.HTTP_401_UNAUTHORIZED,
+        "field": None,
+        "message": "Недействительный токен",
+    }
+
+
+def test_http_validation_exception_extracts_field():
+    client = TestClient(_make_app())
+    response = client.get("/http-422-prefixed")
+
+    assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+    assert response.json() == {
+        "code": status.HTTP_422_UNPROCESSABLE_ENTITY,
+        "field": None,
+        "message": "unknown_column: q5.plan",
+    }
+
+
+def test_sqlalchemy_exception_returns_structured_payload():
+    client = TestClient(_make_app())
+    response = client.get("/sql-error")
+
+    assert response.status_code == status.HTTP_404_NOT_FOUND
+    assert response.json() == {
+        "code": "not_found",
+        "field": None,
+        "message": "budget_form #99 не существует",
+    }

api/tests/unit/test_export_normalizers.py

@@ -0,0 +1,75 @@
+from src.services.export_normalizers import (
+    ExcelValueSerializer,
+    Form1RowNormalizer,
+    Form3ReportRowNormalizer,
+    SmetaRowNormalizer,
+)
+
+
+def test_form1_normalizer_merges_header_and_contract_fields():
+    serializer = ExcelValueSerializer()
+    normalizer = Form1RowNormalizer(serializer)
+    row = {
+        "header": {"section": "1.00.0.", "item_id": 1, "name": "A"},
+        "contract_detail": {"reference": "DOG-1", "amount": 10},
+        "plan": {"q1": 7},
+    }
+
+    normalized = normalizer.normalize(row)
+
+    assert normalized["section"] == "1.00.0."
+    assert normalized["item_id"] == 1
+    assert normalized["name"] == "A"
+    assert normalized["q1"] == 7
+    assert normalized["contract"] == "DOG-1"
+    assert normalized["contract_sum"] == 10
+    assert "header" not in normalized
+
+
+def test_smeta_normalizer_extracts_nested_values():
+    normalizer = SmetaRowNormalizer()
+    row = {
+        "section_code": "1",
+        "name": "SMETA row",
+        "plan": {"support": {"q1": 5}, "total_year": 20},
+        "approved": {"development": {"year": 8}},
+    }
+
+    normalized = normalizer.normalize(row)
+
+    assert normalized["section_code"] == "1"
+    assert normalized["name"] == "SMETA row"
+    assert normalized["plan_support_q1"] == 5
+    assert normalized["plan_total_year"] == 20
+    assert normalized["approved_development_year"] == 8
+
+
+def test_excel_value_serializer_formats_collections():
+    serializer = ExcelValueSerializer()
+
+    assert serializer.to_excel_value(["a", 1, None]) == "a, 1, "
+    assert serializer.to_excel_value({"name": "X"}) == "X"
+    assert serializer.to_excel_value({"k": {"nested": 1}}) == "k=1"
+
+
+def test_form3_normalizer_flattens_quarters_and_totals_to_scalars():
+    normalizer = Form3ReportRowNormalizer()
+    row = {
+        "header": {"section_code": "1.00.0.", "item_id": "R001", "name": "Строка"},
+        "q1": {"quarter_actual": 10, "total_corr": 12},
+        "q2": {"total_corr": 22},
+        "q3": {"economy": 1.5},
+        "q4": {"m1": 100},
+        "totals": {"total_actual": 40, "economy": 2.1},
+    }
+
+    normalized = normalizer.normalize(row)
+
+    assert normalized["section"] == "1.00.0."
+    assert normalized["item_id"] == "R001"
+    assert normalized["name"] == "Строка"
+    assert normalized["q1"] == 10
+    assert normalized["q2"] == 22
+    assert normalized["q3"] == 1.5
+    assert normalized["q4"] is None
+    assert normalized["totals"] == 40

api/tests/unit/test_export_service_query_params.py

@@ -0,0 +1,115 @@
+import io
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, call
+
+import pytest
+
+from src.db.models.form_type import FormTypeEnum
+from src.domain.schemas import DirectionSchemaEnum
+from src.services.export_service import ExportService
+
+
+def _build_form(
+    *,
+    form_type_code: FormTypeEnum = FormTypeEnum.FORM_1,
+    sheet_list: list[str] | None = None,
+    section_list: list[str] | None = None,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        id=1,
+        year=2026,
+        form_type_code=form_type_code.value,
+        org_unit_id=10,
+        org_unit=SimpleNamespace(title="Org"),
+        form_type=SimpleNamespace(
+            code=form_type_code,
+            sheet_list=sheet_list or ["AHR", "SMETA"],
+            section_list=section_list or ["plan", "q1"],
+        ),
+    )
+
+
+@pytest.mark.asyncio
+async def test_export_sheet_rejects_direction_for_unsupported_sheet():
+    service = ExportService(AsyncMock())
+    service.budget_form_service.get = AsyncMock(
+        return_value=_build_form(sheet_list=["SMETA"])
+    )
+    service.sheet_service.get = AsyncMock(return_value=[])
+
+    with pytest.raises(ValueError, match="direction допустим только"):
+        await service.export_form_to_xlsx(
+            form_id=1,
+            current_user=SimpleNamespace(),
+            sheet="SMETA",
+            direction=DirectionSchemaEnum.SUPPORT.value,
+        )
+
+
+@pytest.mark.asyncio
+async def test_export_sheet_rejects_sections_for_unsupported_sheet():
+    service = ExportService(AsyncMock())
+    service.budget_form_service.get = AsyncMock(
+        return_value=_build_form(sheet_list=["SMETA"])
+    )
+    service.sheet_service.get = AsyncMock(return_value=[])
+
+    with pytest.raises(ValueError, match="sections не поддерживается"):
+        await service.export_form_to_xlsx(
+            form_id=1,
+            current_user=SimpleNamespace(),
+            sheet="SMETA",
+            sections=["q1"],
+        )
+
+
+@pytest.mark.asyncio
+async def test_export_full_form_ignores_non_applicable_params_for_other_sheets():
+    service = ExportService(AsyncMock())
+    service.budget_form_service.get = AsyncMock(return_value=_build_form())
+    service.sheet_service.get = AsyncMock(return_value=[])
+
+    stream, filename = await service.export_form_to_xlsx(
+        form_id=1,
+        current_user=SimpleNamespace(),
+        direction=DirectionSchemaEnum.SUPPORT.value,
+        sections=["q1"],
+        ignore_non_applicable_query_params=True,
+    )
+
+    assert stream.getbuffer().nbytes > 0
+    assert filename.endswith(".xlsx")
+    assert service.sheet_service.get.await_args_list == [
+        call(
+            form_id=1,
+            sheet="AHR",
+            direction=DirectionSchemaEnum.SUPPORT.value,
+            sections=["q1"],
+        ),
+        call(
+            form_id=1,
+            sheet="SMETA",
+            direction=None,
+            sections=None,
+        ),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_export_form_payload_forwards_ignore_flag():
+    service = ExportService(AsyncMock())
+    service.export_form_to_xlsx = AsyncMock(return_value=(io.BytesIO(), "demo.xlsx"))
+
+    await service.export_form_payload(
+        form_id=1,
+        current_user=SimpleNamespace(),
+        ignore_non_applicable_query_params=True,
+    )
+
+    assert service.export_form_to_xlsx.await_count == 1
+    assert (
+        service.export_form_to_xlsx.await_args.kwargs[
+            "ignore_non_applicable_query_params"
+        ]
+        is True
+    )

api/tests/unit/test_export_writers.py

@@ -0,0 +1,60 @@
+from unittest.mock import AsyncMock
+
+from openpyxl import Workbook
+
+from src.services.export_service import ExportService
+from src.services.export_writers import (
+    FORM1_FLAT_COLUMNS,
+    SMETA_COLUMNS,
+    TabularSheetWriter,
+)
+
+
+def test_tabular_sheet_writer_writes_headers_and_rows():
+    writer = TabularSheetWriter(
+        columns=[("a", "A"), ("b", "B")],
+        row_normalizer=lambda row: row,
+        value_serializer=lambda value: value,
+    )
+    wb = Workbook()
+    ws = wb.active
+
+    rows = [(None, None, None, {"a": 1, "b": 2})]
+    writer.write(ws, rows)
+
+    assert ws.cell(row=1, column=1).value == "A"
+    assert ws.cell(row=1, column=2).value == "B"
+    assert ws.cell(row=2, column=1).value == 1
+    assert ws.cell(row=2, column=2).value == 2
+
+
+def test_sheet_column_contracts_are_stable():
+    assert len(FORM1_FLAT_COLUMNS) == 17
+    assert len(SMETA_COLUMNS) == 41
+    assert FORM1_FLAT_COLUMNS[0] == ("section", "Код раздела")
+    assert SMETA_COLUMNS[0] == ("section_code", "Код раздела")
+
+
+def test_export_service_uses_sheet_writer_strategy():
+    service = ExportService(AsyncMock())
+
+    class Recorder:
+        def __init__(self):
+            self.calls = 0
+
+        def write(self, worksheet, rows):
+            self.calls += 1
+            worksheet.append(["ok"])
+
+    default_writer = Recorder()
+    smeta_writer = Recorder()
+    service.sheet_writers = {"__default__": default_writer, "SMETA": smeta_writer}
+
+    wb = Workbook()
+    ws_default = wb.active
+    ws_smeta = wb.create_sheet("smeta")
+    service._write_sheet_rows(ws_default, [], "AHR")
+    service._write_sheet_rows(ws_smeta, [], "SMETA")
+
+    assert default_writer.calls == 1
+    assert smeta_writer.calls == 1

api/tests/unit/test_query_validation.py

@@ -0,0 +1,74 @@
+import pytest
+from fastapi import HTTPException
+
+from src.api.v1.forms import _parse_sections_csv, _validate_sheet_query_params
+from src.api.v1.projects import _parse_sections
+from src.db.models.form_type import FormTypeEnum
+from src.domain.schemas import DirectionSchemaEnum
+
+
+def test_parse_sections_csv_returns_none_for_empty_values():
+    assert _parse_sections_csv(None) is None
+    assert _parse_sections_csv("") is None
+    assert _parse_sections_csv(" , , ") is None
+
+
+def test_parse_sections_csv_splits_and_trims():
+    assert _parse_sections_csv("plan, q1, q2 ") == ["plan", "q1", "q2"]
+
+
+def test_validate_sheet_query_requires_direction_for_form1_ahr_cap():
+    with pytest.raises(HTTPException) as exc:
+        _validate_sheet_query_params(FormTypeEnum.FORM_1, "AHR", None, None)
+    assert exc.value.status_code == 400
+
+
+def test_validate_sheet_query_rejects_direction_for_non_form1_or_non_ahr_cap():
+    with pytest.raises(HTTPException) as exc1:
+        _validate_sheet_query_params(
+            FormTypeEnum.FORM_2,
+            "AHR",
+            DirectionSchemaEnum.SUPPORT,
+            None,
+        )
+    assert exc1.value.status_code == 400
+
+    with pytest.raises(HTTPException) as exc2:
+        _validate_sheet_query_params(
+            FormTypeEnum.FORM_1,
+            "SMETA",
+            DirectionSchemaEnum.SUPPORT,
+            None,
+        )
+    assert exc2.value.status_code == 400
+
+
+def test_validate_sheet_query_rejects_sections_for_non_main_sheets():
+    with pytest.raises(HTTPException) as exc:
+        _validate_sheet_query_params(FormTypeEnum.FORM_1, "SMETA", None, ["q1"])
+    assert exc.value.status_code == 400
+
+
+def test_validate_sheet_query_accepts_valid_combinations():
+    _validate_sheet_query_params(
+        FormTypeEnum.FORM_1,
+        "AHR",
+        DirectionSchemaEnum.SUPPORT,
+        ["plan", "q1"],
+    )
+    _validate_sheet_query_params(
+        FormTypeEnum.FORM_2,
+        "AHR",
+        None,
+        ["plan", "q1"],
+    )
+
+
+def test_parse_form3_sections_accepts_supported_values():
+    assert _parse_sections("q1,q2,year") == ["q1", "q2", "year"]
+
+
+def test_parse_form3_sections_rejects_invalid_values():
+    with pytest.raises(HTTPException) as exc:
+        _parse_sections("q1,q5")
+    assert exc.value.status_code == 400

web/package.json

@@ -9,10 +9,18 @@
     "preview": "rsbuild preview"
   },
   "dependencies": {
-    "raisa-ui": "^1.0.0",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.1",
+    "@mui/material": "^9.0.1",
+    "@mui/x-tree-view": "^9.1.0",
+    "axios": "^1.16.1",
+    "date-fns": "^4.1.0",
+    "material-react-table": "^3.2.1",
     "react": "^18.3.1",
+    "react-daisyui": "^5.0.5",
     "react-dom": "^18.3.1",
-    "react-daisyui": "^5.0.5"
+    "react-router-dom": "^7.15.1",
+    "react-toastify": "^11.1.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
@@ -20,8 +28,8 @@
     "@rsbuild/plugin-react": "^1.1.0",
     "@types/react": "^18.3.1",
     "@types/react-dom": "^18.3.1",
-    "typescript": "^5.7.3",
     "daisyui": "^4.12.10",
-    "tailwindcss": "^3.4.13"
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.7.3"
   }
 }

web/public/images/AddColumn.svg

@@ -0,0 +1,5 @@
+<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M13.0603 2.45912L13.0603 17.5497L13.0603 18.8228L6.93989 18.8228L6.93989 17.5497L6.93989 2.45912L6.93989 1.18603L13.0603 1.18603L13.0603 2.45912ZM11.7881 2.45912L11.7881 17.5497L8.21209 17.5497L8.21209 2.45912L11.7881 2.45912Z" fill="#60A9FF"/>
+<path d="M16.6363 3.64075C16.6363 3.38385 16.499 3.10257 16.1808 2.86393C15.8625 2.6253 15.3932 2.45912 14.8483 2.45912L13.0603 2.45912L13.0603 1.18603L14.8483 1.18603C15.6419 1.18603 16.3854 1.42657 16.9444 1.84566C17.5035 2.26512 17.9094 2.89348 17.9094 3.64075L17.9094 16.368C17.9094 17.1153 17.5035 17.7437 16.9444 18.1631C16.3854 18.5823 15.6419 18.8228 14.8483 18.8228L13.0603 18.8228L13.0603 17.5497L14.8483 17.5497C15.3932 17.5497 15.8625 17.3835 16.1808 17.1448C16.499 16.9062 16.6363 16.6249 16.6363 16.368L16.6363 3.64075Z" fill="#4A5565"/>
+<path d="M5.1519 2.45912C4.60695 2.45912 4.13768 2.6253 3.81934 2.86394C3.50117 3.10257 3.3639 3.38385 3.3639 3.64076L3.3639 16.368C3.3639 16.6249 3.50118 16.9062 3.81934 17.1448C4.13768 17.3835 4.60695 17.5497 5.1519 17.5497L6.93989 17.5497L6.93989 18.8228L5.1519 18.8228C4.35825 18.8228 3.61486 18.5823 3.05584 18.1631C2.4966 17.7437 2.09082 17.1153 2.09082 16.368L2.09082 3.64076C2.09082 2.89348 2.4966 2.26512 3.05584 1.84566C3.61486 1.42657 4.35825 1.18603 5.1519 1.18603L6.93989 1.18603L6.93989 2.45912L5.1519 2.45912Z" fill="#4A5565"/>
+</svg>

web/public/images/AddLayer.svg

@@ -0,0 +1,5 @@
+<svg width="20" height="21" viewBox="0 0 20 21" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M0 10.5409V17.5409C0 19.0321 1.20903 20.2411 2.7002 20.2411H12.7002C14.1914 20.2411 15.4004 19.0321 15.4004 17.5409V16.2411H14V17.5409C14 18.2589 13.4182 18.8407 12.7002 18.8407H2.7002C1.98223 18.8407 1.40039 18.2589 1.40039 17.5409V10.5409C1.40039 9.82292 1.98223 9.24109 2.7002 9.24109H4V7.8407H2.7002C1.20903 7.8407 0 9.04972 0 10.5409Z" fill="#323031"/>
+<path d="M10.9999 0.700195C10.9999 0.313596 11.3135 4.09655e-08 11.7001 0C12.0867 5.14389e-07 12.4003 0.313596 12.4003 0.700195V8.00977L14.205 6.20508C14.4783 5.93171 14.9218 5.93171 15.1952 6.20508C15.4686 6.47845 15.4686 6.92195 15.1952 7.19531L12.1952 10.1953C11.9218 10.4687 11.4783 10.4687 11.205 10.1953L8.20503 7.19531C7.93166 6.92195 7.93166 6.47845 8.20503 6.20508C8.4784 5.93171 8.9219 5.93171 9.19526 6.20508L10.9999 8.00977V0.700195Z" fill="#60A9FF"/>
+<path d="M4 7.8407V6.54126C4 5.05009 5.20903 3.84106 6.7002 3.84106H7.7002C8.08679 3.84106 8.40039 4.15466 8.40039 4.54126C8.40039 4.92786 8.08679 5.24146 7.7002 5.24146H6.7002C5.98223 5.24146 5.40039 5.82329 5.40039 6.54126V13.5412C5.40039 14.2592 5.98223 14.841 6.7002 14.841H16.7002C17.4182 14.841 18 14.2592 18 13.5412V6.54126C18 5.82329 17.4182 5.24146 16.7002 5.24146H15.7002C15.3136 5.24146 15 4.92786 15 4.54126C15 4.15466 15.3136 3.84106 15.7002 3.84106H16.7002C18.1914 3.84106 19.4004 5.05009 19.4004 6.54126V13.5412C19.4004 15.0324 18.1914 16.2414 16.7002 16.2414L15.4004 16.2411H14L6.7002 16.2414C5.20903 16.2414 4 15.0324 4 13.5412V9.24109V7.8407Z" fill="#60A9FF"/>
+</svg>

web/public/images/AddLine.svg

@@ -0,0 +1,5 @@
+<svg width="20" height="20" viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M17.1073 13.0603H2.01673H0.743652V6.93989H2.01673H17.1073H18.3804V13.0603H17.1073ZM17.1073 11.7881H2.01673V8.21209H17.1073V11.7881Z" fill="#60A9FF"/>
+<path d="M15.9257 16.6363C16.1826 16.6363 16.4638 16.499 16.7025 16.1808C16.9411 15.8625 17.1073 15.3932 17.1073 14.8483V13.0603H18.3804V14.8483C18.3804 15.6419 18.1398 16.3854 17.7207 16.9444C17.3013 17.5035 16.6729 17.9094 15.9257 17.9094H3.19838C2.45109 17.9094 1.82271 17.5035 1.40328 16.9444C0.984144 16.3854 0.743652 15.6419 0.743652 14.8483V13.0603H2.01673V14.8483C2.01673 15.3932 2.18288 15.8625 2.42156 16.1808C2.66018 16.499 2.94151 16.6363 3.19838 16.6363H15.9257Z" fill="#4A5565"/>
+<path d="M17.1073 5.1519C17.1073 4.60695 16.9411 4.13768 16.7025 3.81934C16.4638 3.50117 16.1826 3.3639 15.9257 3.3639H3.19838C2.94151 3.3639 2.66018 3.50117 2.42156 3.81934C2.18288 4.13768 2.01673 4.60695 2.01673 5.1519V6.93989H0.743652V5.1519C0.743652 4.35825 0.984144 3.61486 1.40328 3.05584C1.82271 2.4966 2.45109 2.09082 3.19838 2.09082H15.9257C16.6729 2.09082 17.3013 2.4966 17.7207 3.05584C18.1398 3.61486 18.3804 4.35825 18.3804 5.1519V6.93989H17.1073V5.1519Z" fill="#4A5565"/>
+</svg>