From 364bc616fbc8ee6c60f3d4d74eea7b86a4cc66ac Mon Sep 17 00:00:00 2001 From: romanskijdev Date: Wed, 5 Aug 2026 08:50:26 +0300 Subject: [PATCH] Updated approvals lit filters --- service/rest_admin_service/admin_api.txt | 16045 ++++++++++++++++ .../handlers/approvals/handlers.go | 7 + 2 files changed, 16052 insertions(+) create mode 100644 service/rest_admin_service/admin_api.txt diff --git a/service/rest_admin_service/admin_api.txt b/service/rest_admin_service/admin_api.txt new file mode 100644 index 0000000..93c383c --- /dev/null +++ b/service/rest_admin_service/admin_api.txt @@ -0,0 +1,16045 @@ +├── .gitignore +├── .golangci.yml +├── README.MD +├── cmd +│ ├── app.go +├── docs +│ ├── docs.go +│ ├── swagger.json +│ ├── swagger.yaml +├── go.mod +├── go.sum +├── handlers +│ ├── admin +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── admin_actions +│ │ ├── handlers.go +│ ├── approval_steps +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── approval_tasks +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── approvalextras +│ │ ├── handler.go +│ ├── approvals +│ │ ├── files.go +│ │ ├── handlers.go +│ │ ├── reports.go +│ │ ├── routes.go +│ ├── auth +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── dashboard +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── departments +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── flow_nodes +│ │ ├── handler.go +│ │ ├── preview.go +│ │ ├── router.go +│ │ ├── utils.go +│ ├── middleware.go +│ ├── notification +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── permission +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── profile +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── register.go +│ ├── roles +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── system_monitoring +│ │ ├── handlers.go +│ ├── topic_categories +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── topic_executors +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── topics +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── user_hierarchy +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── user_roles +│ │ ├── handlers.go +│ │ ├── routes.go +│ ├── users +│ │ ├── handlers.go +│ │ ├── routes.go +├── types +│ ├── module.go +│ ├── req.go +├── version +File: cmd/app.go +Lines: 256 +-----BEGIN cmd/app.go----- +package main + +import ( + configcore "bitrix_balancer_api/core/config" + clientcontrollers "bitrix_balancer_api/core/lib/internally/client-controllers" + _ "bitrix_balancer_api/rest_admin_service/docs" + adminhandler "bitrix_balancer_api/rest_admin_service/handlers/admin" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + approvalstepshandler "bitrix_balancer_api/rest_admin_service/handlers/approval_steps" + approvaltaskshandler "bitrix_balancer_api/rest_admin_service/handlers/approval_tasks" + approvalextrashandler "bitrix_balancer_api/rest_admin_service/handlers/approvalextras" + approvalshandler "bitrix_balancer_api/rest_admin_service/handlers/approvals" + authhandler "bitrix_balancer_api/rest_admin_service/handlers/auth" + dashboardhandler "bitrix_balancer_api/rest_admin_service/handlers/dashboard" + departmentshandler "bitrix_balancer_api/rest_admin_service/handlers/departments" + nodeshandler "bitrix_balancer_api/rest_admin_service/handlers/flow_nodes" + notificationshandler "bitrix_balancer_api/rest_admin_service/handlers/notification" + permissionshandler "bitrix_balancer_api/rest_admin_service/handlers/permission" + profilehandler "bitrix_balancer_api/rest_admin_service/handlers/profile" + roleshandler "bitrix_balancer_api/rest_admin_service/handlers/roles" + categorieshandler "bitrix_balancer_api/rest_admin_service/handlers/topic_categories" + topicexecutorshandler "bitrix_balancer_api/rest_admin_service/handlers/topic_executors" + topicshandler "bitrix_balancer_api/rest_admin_service/handlers/topics" + hierarchieshandler "bitrix_balancer_api/rest_admin_service/handlers/user_hierarchy" + userroleshandler "bitrix_balancer_api/rest_admin_service/handlers/user_roles" + usershandler "bitrix_balancer_api/rest_admin_service/handlers/users" + typesm "bitrix_balancer_api/rest_admin_service/types" + "errors" + "fmt" + "github.com/go-chi/chi/v5" + "github.com/go-chi/chi/v5/middleware" + "github.com/go-chi/cors" + "github.com/go-chi/httprate" + "github.com/sirupsen/logrus" + httpSwagger "github.com/swaggo/http-swagger" + "log" + "net/http" + "time" +) + +const ( + readTimeout = 15 * time.Minute // Таймаут чтения + writeTimeout = 15 * time.Minute // Таймаут записи + idleTimeout = 15 * time.Minute // Таймаут бездействия + rateLimit = 15 // Лимит запросов + rateWindow = 1 * time.Second // Окно времени для лимита запросов +) + +// @title RusPet Admin API +// @version 0.1 +// @description API админ-панели для системы согласований +// @description +// @description ## Возможности +// @description - Управление отделами, ролями и пользователями +// @description - Настройка тем и категорий согласований +// @description - Управление иерархией согласований +// @description - Назначение исполнителей и прав +// @description - Просмотр заявок и шагов согласования +// @description +// @description ## Аутентификация +// @description Все защищённые эндпоинты требуют: +// @description - `Authorization: Bearer ` — JWT токен администратора +// @description - `ApiKey: ` — HMAC подпись для верификации клиента +// @description - `X-Timestamp: ` — Unix timestamp (не старше 3 минут) +// @description - `x-device-id: ` — ID устройства +// +// @host localhost:8080 +// @BasePath / +// +// @securityDefinitions.apikey BearerAuth +// @in header +// @name Authorization +// +// @securityDefinitions.apikey ApiKeyAuth +// @in header +// @name ApiKey +// +// @securityDefinitions.apikey DeviceID +// @in header +// @name x-device-id +// +// @securityDefinitions.apikey Timestamp +// @in header +// @name X-Timestamp +// +// @contact.name Roman +// @contact.email romanzabolotskij0@gmail.com +func main() { + err := initService() + if err != nil { + logrus.Errorln("🔴 failed to init common: ", err) + } + select {} +} + +func initService() error { + clientsExternal, err := getClientsExternal() + if err != nil { + logrus.Errorln("🔴 failed to load config: ", err) + return err + } + + ipc, err := initInternalProvider(clientsExternal) + if err != nil { + logrus.Errorln("🔴 failed to init internal provider: ", err) + return err + } + + router, err := initBaseApiRouter(ipc) + if err != nil { + logrus.Errorln("🔴 failed to init base api router: ", err) + return err + } + + if err := startRestApiServer(ipc, router); err != nil { + logrus.Errorln("🔴 failed to start server: ", err) + return err + } + + return nil +} + +func getClientsExternal() (clientcontrollers.ClientsExternal, error) { + options := &configcore.ConfigLoadOptions{ + Redis: true, + Database: true, + Telegram: true, + Secrets: configcore.SecretsOptions{ + AuthJWT: configcore.AuthJWTOptions{ + Admin: true, + }, + AdminAccessCode: true, + }, + Server: configcore.ExposedServiceOptions{ + RESTAdminService: true, + }, + } + + return clientcontrollers.ReturnClientsExternal(options) +} + +func initInternalProvider(clientsExternal clientcontrollers.ClientsExternal) (*typesm.InternalProviderControl, error) { + return &typesm.InternalProviderControl{ + Config: clientsExternal.Config, + RedisClient: clientsExternal.Redis, + Database: clientsExternal.DB, + TGBotClient: clientsExternal.Telegram, + }, nil +} + +func startRestApiServer(ipc *typesm.InternalProviderControl, router *chi.Mux) error { + serverPort := fmt.Sprintf("%d", ipc.Config.Server.RESTAdminService.PortRest) + + serverAddr := ":" + serverPort + httpServer := &http.Server{ + Addr: serverAddr, + Handler: router, + ReadTimeout: readTimeout, + WriteTimeout: writeTimeout, + IdleTimeout: idleTimeout, + } + + log.Printf("✅ Starting server on %s", serverAddr) + return httpServer.ListenAndServe() +} + +func initBaseApiRouter(ipc *typesm.InternalProviderControl) (*chi.Mux, error) { + router := chi.NewRouter() + corsOptions := cors.New(cors.Options{ + AllowedOrigins: ipc.Config.Server.RESTAdminService.Cors.AllowedOrigins, // Список разрешенных origin + AllowedMethods: []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodDelete, http.MethodPatch, http.MethodOptions}, + AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "ApiKey", "x-device-id"}, + ExposedHeaders: []string{"Link", "Cache-Control"}, + AllowCredentials: false, + MaxAge: 300, // Максимальное время жизни предварительных запросов в секундах + }) + + router.Use(corsOptions.Handler) + router.Use(middleware.RealIP) + router.Use(middleware.Recoverer) + // Добавляем ограничение по IP + router.Use(httprate.LimitByIP(rateLimit, rateWindow)) + + if ipc.Database == nil { + return nil, errors.New("failed_to_connect_db") + } + + err := registerRoutes(router, ipc) + if err != nil { + return nil, err + } + + return router, nil +} + +// регистрирует маршруты +func registerRoutes(router chi.Router, ipc *typesm.InternalProviderControl) error { + router.Get("/swagger/*", httpSwagger.Handler( + httpSwagger.URL("/swagger/doc.json"), // URL к сгенерированному JSON + httpSwagger.DeepLinking(true), + httpSwagger.DocExpansion("none"), + httpSwagger.DomID("swagger-ui"), + )) + + // Слайс обработчиков маршрутов + routeHandlers := []struct { + name string + handler func(chi.Router, *typesm.InternalProviderControl) error + }{ + {"admin", adminhandler.RegisterAdminRoutes}, + {"auth", authhandler.RegisterAuthRoutes}, + {"profile", profilehandler.RegisterProfileRoutes}, + {"users", usershandler.RegisterUserRoutes}, + {"departments", departmentshandler.RegisterDepartmentRoutes}, + {"roles", roleshandler.RegisterRoleRoutes}, + {"categories", categorieshandler.RegisterCategoryRoutes}, + {"topics", topicshandler.RegisterTopicRoutes}, + {"user-roles", userroleshandler.RegisterUserRoleRoutes}, + {"hierarchies", hierarchieshandler.RegisterHierarchyRoutes}, + {"topic-executors", topicexecutorshandler.RegisterTopicExecutorRoutes}, + {"approvals", approvalshandler.RegisterApprovalRoutes}, + {"approval-steps", approvalstepshandler.RegisterApprovalStepRoutes}, + {"permissions", permissionshandler.RegisterPermissionRoutes}, + {"approval-tasks", approvaltaskshandler.RegisterApprovalTasksRoutes}, + {"dashboard", dashboardhandler.RegisterDashboardRoutes}, + {"notifications", notificationshandler.RegisterNotificationRoutes}, + {"flownodes", nodeshandler.RegisterFlowNodesRoutes}, + {"approvalextras", approvalextrashandler.RegisterApprovalExtrasRoutes}, + {"adminlog", adminloghandler.RegisterAdminLogRoutes}, + } + + // Регистрация всех маршрутов + for _, rh := range routeHandlers { + if errObj := rh.handler(router, ipc); errObj != nil { + return errors.New(fmt.Sprintf("🔴 failed to register %s routes", rh.name)) + } + } + + // Вывод зарегистрированных маршрутов + if err := printRoutes(router, ipc); err != nil { + return errors.New(fmt.Sprintf("🔴 failed to print routes: %v", err)) + } + + return nil +} + +func printRoutes(r chi.Router, ipc *typesm.InternalProviderControl) error { + err := chi.Walk(r, func(method, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error { + logrus.Info(fmt.Sprintf("🩵 [ %s ] %s\n", method, route)) + return nil + }) + if err != nil { + return err + } + return nil +} + +-----END cmd/app.go----- + +File: docs/docs.go +Lines: 3990 +-----BEGIN docs/docs.go----- +// Package docs Code generated by swaggo/swag. DO NOT EDIT +package docs + +import "github.com/swaggo/swag" + +const docTemplate = `{ + "schemes": {{ marshal .Schemes }}, + "swagger": "2.0", + "info": { + "description": "{{escape .Description}}", + "title": "{{.Title}}", + "contact": {}, + "version": "{{.Version}}" + }, + "host": "{{.Host}}", + "basePath": "{{.BasePath}}", + "paths": { + "/api/admin": { + "get": { + "description": "Получение списка администраторов", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "admin" + ], + "summary": "Получение списка администраторов", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "boolean", + "description": "Фильтр по активности", + "name": "is_active", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Admin" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Создание администратора", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "admin" + ], + "summary": "Создание администратора", + "parameters": [ + { + "description": "Запрос", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.AdminReq" + } + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/typescore.Admin" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление администратора", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "admin" + ], + "summary": "Удаление администратора", + "parameters": [ + { + "description": "Запрос", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.AdminReq" + } + } + ], + "responses": { + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/admin/profile": { + "get": { + "description": "Получение профиля пользователя", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "profile" + ], + "summary": "Получение профиля пользователя", + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/typescore.Admin" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление профиля пользователя", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "profile" + ], + "summary": "Обновление профиля пользователя", + "parameters": [ + { + "description": "Запрос", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.AdminReq" + } + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/typescore.Admin" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/approval-steps": { + "get": { + "description": "Получение списка шагов согласования с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approval-steps" + ], + "summary": "Получение списка шагов", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по заявке", + "name": "approval_id", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по согласующему", + "name": "approver_id", + "in": "query" + }, + { + "type": "string", + "description": "Фильтр по статусу (pending, waiting, approved, rejected, cancelled_any_of)", + "name": "status", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных шага согласования (статус, комментарий)", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approval-steps" + ], + "summary": "Обновление шага", + "parameters": [ + { + "description": "Данные шага", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalStep" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalStep" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Шаг не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Создание нового шага согласования для заявки", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approval-steps" + ], + "summary": "Создание шага", + "parameters": [ + { + "description": "Данные шага", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalStep" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalStep" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Заявка или согласующий не найдены", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление шага согласования (только для заявок в статусе pending)", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approval-steps" + ], + "summary": "Удаление шага", + "parameters": [ + { + "description": "ID шага для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalStep" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "403": { + "description": "Нельзя удалить шаг завершённой заявки", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Шаг не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/approval-steps/by-approval/{approval_id}": { + "get": { + "description": "Получение списка всех шагов согласования для указанной заявки, отсортированных по step_order", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approval-steps" + ], + "summary": "Получение шагов по заявке", + "parameters": [ + { + "type": "integer", + "description": "ID заявки", + "name": "approval_id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Заявка не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/approval-steps/{id}": { + "get": { + "description": "Получение детальной информации о шаге согласования по его ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approval-steps" + ], + "summary": "Получение шага по ID", + "parameters": [ + { + "type": "integer", + "description": "ID шага", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalStep" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Шаг не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/approvals": { + "get": { + "description": "Получение списка заявок с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approvals" + ], + "summary": "Получение списка заявок", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "string", + "description": "Фильтр по статусу (pending, approved, rejected, revoked, revision)", + "name": "status", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по инициатору", + "name": "initiator_id", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по теме", + "name": "topic_id", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по отделу", + "name": "department_id", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных заявки (статус, комментарии и т.д.)", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approvals" + ], + "summary": "Обновление заявки", + "parameters": [ + { + "description": "Данные заявки", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Approval" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Approval" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Заявка не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление заявки (только для черновиков)", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approvals" + ], + "summary": "Удаление заявки", + "parameters": [ + { + "description": "ID заявки для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Approval" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "403": { + "description": "Нельзя удалить не-черновую заявку", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Заявка не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/approvals/report": { + "get": { + "description": "Получение списка заявок для отчёта с учётом периода и доступа пользователя", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approvals" + ], + "summary": "Получение заявок для отчёта", + "parameters": [ + { + "type": "integer", + "description": "ID пользователя (если не указан - все заявки)", + "name": "user_id", + "in": "query" + }, + { + "type": "string", + "description": "Начальная дата (YYYY-MM-DD)", + "name": "date_from", + "in": "query" + }, + { + "type": "string", + "description": "Конечная дата (YYYY-MM-DD)", + "name": "date_to", + "in": "query" + }, + { + "type": "boolean", + "description": "Полный доступ (игнорировать фильтрацию по пользователю)", + "name": "all_access", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/approvals/{id}": { + "get": { + "description": "Получение детальной информации о заявке по её ID со всеми связанными данными", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "approvals" + ], + "summary": "Получение заявки по ID", + "parameters": [ + { + "type": "integer", + "description": "ID заявки", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Approval" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Заявка не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/auth/login": { + "post": { + "description": "авторизация с помощью связки логин-пароль", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "auth" + ], + "summary": "авторизация с помощью связки логин-пароль", + "parameters": [ + { + "description": "Запрос", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.AuthReqAccount" + } + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/typescore.AuthHandlerResponse" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/auth/token": { + "post": { + "description": "Авторизация при помощи JWT-токена", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "auth" + ], + "summary": "Авторизация при помощи JWT-токена", + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/typescore.AuthHandlerResponse" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/categories": { + "get": { + "description": "Получение списка категорий тем с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "categories" + ], + "summary": "Получение списка категорий тем", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "boolean", + "description": "Фильтр по активности", + "name": "is_active", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных существующей категории", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "categories" + ], + "summary": "Обновление категории", + "parameters": [ + { + "description": "Данные категории", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Категория не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Создание новой категории тем", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "categories" + ], + "summary": "Создание категории тем", + "parameters": [ + { + "description": "Данные категории", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление категории по ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "categories" + ], + "summary": "Удаление категории", + "parameters": [ + { + "description": "ID категории для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Категория не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "409": { + "description": "Категория содержит темы", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/categories/{id}": { + "get": { + "description": "Получение детальной информации о категории по её ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "categories" + ], + "summary": "Получение категории по ID", + "parameters": [ + { + "type": "integer", + "description": "ID категории", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Категория не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/departments": { + "get": { + "description": "Получение списка отделов с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "departments" + ], + "summary": "Получение списка отделов", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "boolean", + "description": "Фильтр по активности", + "name": "is_active", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных существующего отдела", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "departments" + ], + "summary": "Обновление отдела", + "parameters": [ + { + "description": "Данные отдела", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Department" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Department" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Отдел не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Создание нового отдела", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "departments" + ], + "summary": "Создание отдела", + "parameters": [ + { + "description": "Данные отдела", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Department" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Department" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление отдела по ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "departments" + ], + "summary": "Удаление отдела", + "parameters": [ + { + "description": "ID отдела для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Department" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Отдел не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/departments/{id}": { + "get": { + "description": "Получение детальной информации об отделе по его ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "departments" + ], + "summary": "Получение отдела по ID", + "parameters": [ + { + "type": "integer", + "description": "ID отдела", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Department" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Отдел не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/hierarchies": { + "get": { + "description": "Получение списка связей подчинённый-согласующий с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "hierarchies" + ], + "summary": "Получение списка записей иерархии", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по подчинённому", + "name": "subordinate_id", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по согласующему", + "name": "approver_id", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по отделу", + "name": "department_id", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных существующей записи иерархии", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "hierarchies" + ], + "summary": "Обновление записи иерархии", + "parameters": [ + { + "description": "Данные иерархии", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.UserHierarchy" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.UserHierarchy" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Запись не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Создание новой связи подчинённый-согласующий", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "hierarchies" + ], + "summary": "Создание записи иерархии", + "parameters": [ + { + "description": "Данные иерархии", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.UserHierarchy" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.UserHierarchy" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "409": { + "description": "Такая связь уже существует", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление связи подчинённый-согласующий по ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "hierarchies" + ], + "summary": "Удаление записи иерархии", + "parameters": [ + { + "description": "ID записи для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.UserHierarchy" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Запись не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/hierarchies/{id}": { + "get": { + "description": "Получение детальной информации о записи иерархии по её ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "hierarchies" + ], + "summary": "Получение записи иерархии по ID", + "parameters": [ + { + "type": "integer", + "description": "ID записи", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.UserHierarchy" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Запись не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/permissions": { + "get": { + "description": "Получение списка прав ролей с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "permissions" + ], + "summary": "Получение списка прав", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по роли", + "name": "role_id", + "in": "query" + }, + { + "type": "string", + "description": "Фильтр по действию (create, read, update, delete, approve, revoke)", + "name": "action", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по категории тем", + "name": "topic_category_id", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по теме", + "name": "topic_id", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных существующего права", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "permissions" + ], + "summary": "Обновление права", + "parameters": [ + { + "description": "Данные права", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Permission" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Permission" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Право не найдено", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Назначение права на действие для роли", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "permissions" + ], + "summary": "Создание права", + "parameters": [ + { + "description": "Данные права", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Permission" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Permission" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Роль, категория или тема не найдены", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "409": { + "description": "Такое право уже существует", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление права по ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "permissions" + ], + "summary": "Удаление права", + "parameters": [ + { + "description": "ID права для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Permission" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Право не найдено", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/permissions/by-role/{role_id}": { + "get": { + "description": "Получение списка всех прав для указанной роли", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "permissions" + ], + "summary": "Получение прав по роли", + "parameters": [ + { + "type": "integer", + "description": "ID роли", + "name": "role_id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Роль не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/permissions/{id}": { + "get": { + "description": "Получение детальной информации о праве по его ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "permissions" + ], + "summary": "Получение права по ID", + "parameters": [ + { + "type": "integer", + "description": "ID права", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Permission" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Право не найдено", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/roles": { + "get": { + "description": "Получение списка ролей с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "roles" + ], + "summary": "Получение списка ролей", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных существующей роли", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "roles" + ], + "summary": "Обновление роли", + "parameters": [ + { + "description": "Данные роли", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Role" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Role" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Роль не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Создание новой роли", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "roles" + ], + "summary": "Создание роли", + "parameters": [ + { + "description": "Данные роли", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Role" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Role" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление роли по ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "roles" + ], + "summary": "Удаление роли", + "parameters": [ + { + "description": "ID роли для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.Role" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Роль не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/roles/{id}": { + "get": { + "description": "Получение детальной информации о роли по её ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "roles" + ], + "summary": "Получение роли по ID", + "parameters": [ + { + "type": "integer", + "description": "ID роли", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.Role" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Роль не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/topic-executors": { + "get": { + "description": "Получение списка исполнителей с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topic-executors" + ], + "summary": "Получение списка исполнителей тем", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по теме", + "name": "topic_id", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по пользователю", + "name": "user_id", + "in": "query" + }, + { + "type": "boolean", + "description": "Фильтр по активности", + "name": "is_active", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных исполнителя для темы", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topic-executors" + ], + "summary": "Обновление исполнителя", + "parameters": [ + { + "description": "Данные исполнителя", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicExecutor" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicExecutor" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Исполнитель не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Назначение исполнителя для конкретной темы согласования", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topic-executors" + ], + "summary": "Создание исполнителя", + "parameters": [ + { + "description": "Данные исполнителя", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicExecutor" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicExecutor" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Тема или пользователь не найдены", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "409": { + "description": "Такой исполнитель уже назначен на этот шаг", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление исполнителя из темы по ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topic-executors" + ], + "summary": "Удаление исполнителя", + "parameters": [ + { + "description": "ID записи для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicExecutor" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Запись не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/topic-executors/by-topic/{topic_id}": { + "get": { + "description": "Получение списка всех активных исполнителей для указанной темы, отсортированных по step_order", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topic-executors" + ], + "summary": "Получение исполнителей по теме", + "parameters": [ + { + "type": "integer", + "description": "ID темы", + "name": "topic_id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Тема не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/topic-executors/{id}": { + "get": { + "description": "Получение детальной информации об исполнителе по его ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topic-executors" + ], + "summary": "Получение исполнителя по ID", + "parameters": [ + { + "type": "integer", + "description": "ID исполнителя", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopicExecutor" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Исполнитель не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/topics": { + "get": { + "description": "Получение списка тем с пагинацией и фильтрацией", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topics" + ], + "summary": "Получение списка тем", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по категории", + "name": "category_id", + "in": "query" + }, + { + "type": "boolean", + "description": "Фильтр по активности", + "name": "is_active", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных существующей темы", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topics" + ], + "summary": "Обновление темы", + "parameters": [ + { + "description": "Данные темы", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopic" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopic" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Тема не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Создание новой темы согласования", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topics" + ], + "summary": "Создание темы", + "parameters": [ + { + "description": "Данные темы", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopic" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopic" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление темы по ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topics" + ], + "summary": "Удаление темы", + "parameters": [ + { + "description": "ID темы для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopic" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Тема не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "409": { + "description": "Тема содержит заявки", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/topics/{id}": { + "get": { + "description": "Получение детальной информации о теме по её ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "topics" + ], + "summary": "Получение темы по ID", + "parameters": [ + { + "type": "integer", + "description": "ID темы", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApprovalTopic" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Тема не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/user-roles": { + "get": { + "description": "Получение списка ролей, назначенных конкретному пользователю", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "user-roles" + ], + "summary": "Получение списка ролей пользователя", + "parameters": [ + { + "type": "integer", + "description": "ID пользователя", + "name": "user_id", + "in": "query", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "post": { + "description": "Назначение роли пользователю (создание связи user_id + role_id)", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "user-roles" + ], + "summary": "Назначение роли пользователю", + "parameters": [ + { + "description": "user_id и role_id", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/handlers_user_roles.AssignUserRoleRequest" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.UserRole" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Пользователь или роль не найдены", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "409": { + "description": "Роль уже назначена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "delete": { + "description": "Удаление связи user_id + role_id по ID записи", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "user-roles" + ], + "summary": "Удаление роли у пользователя", + "parameters": [ + { + "description": "ID записи для удаления", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.UserRole" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "type": "boolean" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Запись не найдена", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/user-roles/bulk": { + "post": { + "description": "Полная замена ролей пользователя: удаляет все текущие роли и назначает новые", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "user-roles" + ], + "summary": "Массовое назначение ролей", + "parameters": [ + { + "description": "user_id и список role_ids", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/handlers_user_roles.BulkAssignRolesRequest" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Пользователь не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/users": { + "get": { + "description": "Получение списка пользователей с пагинацией, фильтрацией и подгрузкой связанных данных", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "users" + ], + "summary": "Получение списка пользователей", + "parameters": [ + { + "type": "integer", + "description": "Смещение для пагинации", + "name": "offset", + "in": "query" + }, + { + "type": "integer", + "description": "Количество записей на странице", + "name": "limit", + "in": "query" + }, + { + "type": "boolean", + "description": "Фильтр по блокировке", + "name": "is_blocked", + "in": "query" + }, + { + "type": "boolean", + "description": "Фильтр по увольнению", + "name": "is_fired", + "in": "query" + }, + { + "type": "integer", + "description": "Фильтр по отделу", + "name": "department_id", + "in": "query" + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + }, + "put": { + "description": "Обновление данных существующего пользователя", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "users" + ], + "summary": "Обновление пользователя", + "parameters": [ + { + "description": "Данные пользователя", + "name": "request", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/typescore.UpdateUserReqAdmin" + } + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.User" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Пользователь не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/users/{id}": { + "get": { + "description": "Получение детальной информации о пользователе по его ID с подгрузкой связанных данных", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "users" + ], + "summary": "Получение пользователя по ID", + "parameters": [ + { + "type": "integer", + "description": "ID пользователя", + "name": "id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.User" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Пользователь не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + }, + "/api/users/{user_id}/roles": { + "get": { + "description": "Получение списка ролей, назначенных пользователю с указанным ID", + "consumes": [ + "application/json" + ], + "produces": [ + "application/json" + ], + "tags": [ + "user-roles" + ], + "summary": "Получение списка ролей пользователя по ID", + "parameters": [ + { + "type": "integer", + "description": "ID пользователя", + "name": "user_id", + "in": "path", + "required": true + } + ], + "responses": { + "200": { + "description": "Успех", + "schema": { + "$ref": "#/definitions/typescore.ApiResponseBase" + } + }, + "400": { + "description": "Некорректный запрос", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "404": { + "description": "Пользователь не найден", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + }, + "500": { + "description": "Ошибка сервера", + "schema": { + "$ref": "#/definitions/handlers.ErrorResponse" + } + } + } + } + } + }, + "definitions": { + "handlers.ErrorResponse": { + "type": "object", + "properties": { + "error_code": { + "description": "Код ошибки", + "type": "integer" + }, + "error_description": { + "description": "Описание ошибки", + "type": "string" + } + } + }, + "handlers_user_roles.AssignUserRoleRequest": { + "type": "object", + "properties": { + "role_id": { + "type": "integer" + }, + "user_id": { + "type": "integer" + } + } + }, + "handlers_user_roles.BulkAssignRolesRequest": { + "type": "object", + "properties": { + "role_ids": { + "type": "array", + "items": { + "type": "integer" + } + }, + "user_id": { + "type": "integer" + } + } + }, + "typescore.Admin": { + "type": "object", + "properties": { + "created_at": { + "description": "Дата создания записи", + "type": "string" + }, + "id": { + "description": "Автоматически заполняемое уникальное поле для большого числа записей", + "type": "integer" + }, + "is_blocked": { + "description": "Заблокирован ли администратор", + "type": "boolean" + }, + "last_ip_login": { + "description": "Последний IP входа", + "type": "string" + }, + "last_login": { + "description": "Дата входа", + "type": "string" + }, + "login": { + "description": "Логин администратора", + "type": "string" + } + } + }, + "typescore.AdminReq": { + "type": "object", + "properties": { + "login": { + "type": "string" + }, + "password": { + "description": "Пароль пользователя", + "type": "string" + } + } + }, + "typescore.ApiResponseBase": { + "type": "object", + "properties": { + "data": { + "description": "данные полученные от api" + }, + "total_amount": { + "type": "number" + }, + "total_count": { + "type": "integer" + } + } + }, + "typescore.Approval": { + "type": "object", + "properties": { + "content": { + "description": "введённые пользователем данные по шаблону", + "type": "string" + }, + "created_at": { + "type": "string" + }, + "department": { + "$ref": "#/definitions/typescore.Department" + }, + "department_id": { + "description": "снимок отдела на момент создания", + "type": "integer" + }, + "files": { + "type": "array", + "items": { + "$ref": "#/definitions/typescore.ApprovalFile" + } + }, + "id": { + "type": "integer" + }, + "initiator": { + "$ref": "#/definitions/typescore.User" + }, + "initiator_id": { + "type": "integer" + }, + "metadata": { + "type": "string" + }, + "revision_at": { + "type": "string" + }, + "revision_by_id": { + "type": "integer" + }, + "revision_comment": { + "type": "string" + }, + "revision_count": { + "type": "integer" + }, + "revoked_at": { + "type": "string" + }, + "revoked_by": { + "$ref": "#/definitions/typescore.User" + }, + "revoked_by_id": { + "type": "integer" + }, + "status": { + "type": "string" + }, + "steps": { + "type": "array", + "items": { + "$ref": "#/definitions/typescore.ApprovalStep" + } + }, + "topic": { + "$ref": "#/definitions/typescore.ApprovalTopic" + }, + "topic_id": { + "type": "integer" + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.ApprovalFile": { + "type": "object", + "properties": { + "approval_id": { + "type": "integer" + }, + "attached_by_id": { + "type": "integer" + }, + "created_at": { + "type": "string" + }, + "file_base64": { + "type": "string" + }, + "file_name": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "task_id": { + "type": "integer" + } + } + }, + "typescore.ApprovalStep": { + "type": "object", + "properties": { + "acted_at": { + "type": "string" + }, + "approval": { + "$ref": "#/definitions/typescore.Approval" + }, + "approval_id": { + "type": "integer" + }, + "approver": { + "$ref": "#/definitions/typescore.User" + }, + "approver_department_snapshot": { + "type": "string" + }, + "approver_id": { + "type": "integer" + }, + "approver_name_snapshot": { + "type": "string" + }, + "comment": { + "type": "string" + }, + "created_at": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "returned_at": { + "type": "string" + }, + "status": { + "type": "string" + }, + "step_order": { + "type": "integer" + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.ApprovalTopic": { + "type": "object", + "properties": { + "allow_approver_selection": { + "type": "boolean" + }, + "allow_observer_selection": { + "type": "boolean" + }, + "allows_file": { + "type": "boolean" + }, + "approvalMode": { + "type": "string" + }, + "category": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + }, + "category_id": { + "type": "integer" + }, + "code": { + "type": "string" + }, + "created_at": { + "type": "string" + }, + "duration_type": { + "type": "string" + }, + "first_approver_role_code": { + "description": "если задан — первый согласующий выбирается из этой роли", + "type": "string" + }, + "id": { + "type": "integer" + }, + "instructions": { + "type": "string" + }, + "is_active": { + "type": "boolean" + }, + "name": { + "type": "string" + }, + "payment_type": { + "type": "string" + }, + "require_approver_comment": { + "type": "boolean" + }, + "require_observer_selection": { + "type": "boolean" + }, + "requires_file": { + "type": "boolean" + }, + "template": { + "type": "string" + }, + "time_type": { + "type": "string" + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.ApprovalTopicCategory": { + "type": "object", + "properties": { + "code": { + "description": "otgul, vacation, sick_leave", + "type": "string" + }, + "created_at": { + "type": "string" + }, + "description": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "is_active": { + "type": "boolean" + }, + "name": { + "type": "string" + }, + "topics": { + "type": "array", + "items": { + "$ref": "#/definitions/typescore.ApprovalTopic" + } + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.ApprovalTopicExecutor": { + "type": "object", + "properties": { + "created_at": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "is_active": { + "type": "boolean" + }, + "require_file": { + "type": "boolean" + }, + "step_order": { + "type": "integer" + }, + "target_system": { + "type": "string" + }, + "task_text": { + "type": "string" + }, + "topic": { + "$ref": "#/definitions/typescore.ApprovalTopic" + }, + "topic_id": { + "type": "integer" + }, + "updated_at": { + "type": "string" + }, + "user": { + "$ref": "#/definitions/typescore.User" + }, + "user_id": { + "type": "integer" + } + } + }, + "typescore.AuthHandlerResponse": { + "type": "object", + "properties": { + "temp_session": { + "description": "Временный токен для 2FA", + "type": "string" + }, + "token": { + "description": "токен аутентификации", + "type": "string" + } + } + }, + "typescore.AuthReqAccount": { + "type": "object", + "properties": { + "access_code": { + "type": "string" + }, + "login": { + "type": "string" + }, + "password": { + "type": "string" + }, + "redirect_uri": { + "type": "string" + }, + "token": { + "type": "string" + } + } + }, + "typescore.Department": { + "type": "object", + "properties": { + "code": { + "description": "finance, hr, it", + "type": "string" + }, + "created_at": { + "type": "string" + }, + "description": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "is_active": { + "type": "boolean" + }, + "name": { + "type": "string" + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.Permission": { + "type": "object", + "properties": { + "action": { + "type": "string" + }, + "created_at": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "role": { + "$ref": "#/definitions/typescore.Role" + }, + "role_id": { + "type": "integer" + }, + "topic": { + "$ref": "#/definitions/typescore.ApprovalTopic" + }, + "topic_category": { + "$ref": "#/definitions/typescore.ApprovalTopicCategory" + }, + "topic_category_id": { + "type": "integer" + }, + "topic_id": { + "type": "integer" + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.Role": { + "type": "object", + "properties": { + "code": { + "type": "string" + }, + "created_at": { + "type": "string" + }, + "description": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "is_approver": { + "type": "boolean" + }, + "is_default": { + "type": "boolean" + }, + "is_director": { + "type": "boolean" + }, + "is_executor": { + "type": "boolean" + }, + "is_observer": { + "type": "boolean" + }, + "name": { + "type": "string" + }, + "permissions": { + "type": "array", + "items": { + "$ref": "#/definitions/typescore.Permission" + } + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.UpdateUserReqAdmin": { + "type": "object", + "properties": { + "department_id": { + "description": "Логин пользователя", + "type": "integer" + }, + "id": { + "type": "integer" + }, + "is_blocked": { + "description": "Заблокирован ли пользователь", + "type": "boolean" + }, + "is_fired": { + "description": "Заблокирован ли пользователь", + "type": "boolean" + } + } + }, + "typescore.User": { + "type": "object", + "properties": { + "blocked_at": { + "type": "string" + }, + "created_at": { + "type": "string" + }, + "department": { + "$ref": "#/definitions/typescore.Department" + }, + "department_id": { + "type": "integer" + }, + "full_name": { + "type": "string" + }, + "id": { + "type": "integer" + }, + "is_blocked": { + "type": "boolean" + }, + "is_fired": { + "type": "boolean" + }, + "language_code": { + "description": "FirstName *string ` + "`" + `gorm:\"type:text;not null;column:first_name\" json:\"first_name\" db:\"first_name\" mapstructure:\"first_name\"` + "`" + `\nLastName *string ` + "`" + `gorm:\"type:text;not null;column:last_name\" json:\"last_name\" db:\"last_name\" mapstructure:\"last_name\"` + "`" + `\nPatronymic *string ` + "`" + `gorm:\"type:text;column:patronymic\" json:\"patronymic,omitempty\" db:\"patronymic\" mapstructure:\"patronymic\"` + "`" + `", + "type": "string" + }, + "last_login": { + "type": "string" + }, + "telegram_id": { + "type": "integer" + }, + "updated_at": { + "type": "string" + }, + "user_roles": { + "type": "array", + "items": { + "$ref": "#/definitions/typescore.UserRole" + } + }, + "username": { + "type": "string" + } + } + }, + "typescore.UserHierarchy": { + "type": "object", + "properties": { + "approver": { + "$ref": "#/definitions/typescore.User" + }, + "approver_id": { + "type": "integer" + }, + "created_at": { + "type": "string" + }, + "department": { + "$ref": "#/definitions/typescore.Department" + }, + "department_id": { + "type": "integer" + }, + "id": { + "type": "integer" + }, + "priority": { + "type": "integer" + }, + "subordinate": { + "$ref": "#/definitions/typescore.User" + }, + "subordinate_id": { + "type": "integer" + }, + "topic_category_id": { + "type": "integer" + }, + "topic_id": { + "type": "integer" + }, + "updated_at": { + "type": "string" + } + } + }, + "typescore.UserRole": { + "type": "object", + "properties": { + "created_at": { + "type": "string" + }, + "id": { + "description": "Автоматически заполняемое уникальное поле для большого числа записей", + "type": "integer" + }, + "role": { + "description": "← добавить gorm:\"-\"", + "allOf": [ + { + "$ref": "#/definitions/typescore.Role" + } + ] + }, + "role_id": { + "type": "integer" + }, + "updated_at": { + "type": "string" + }, + "user": { + "description": "← добавить gorm:\"-\"", + "allOf": [ + { + "$ref": "#/definitions/typescore.User" + } + ] + }, + "user_id": { + "type": "integer" + } + } + } + }, + "securityDefinitions": { + "ApiKeyAuth": { + "type": "apiKey", + "name": "ApiKey", + "in": "header" + }, + "BearerAuth": { + "type": "apiKey", + "name": "Authorization", + "in": "header" + }, + "DeviceID": { + "type": "apiKey", + "name": "x-device-id", + "in": "header" + }, + "Timestamp": { + "type": "apiKey", + "name": "X-Timestamp", + "in": "header" + } + } +}` + +// SwaggerInfo holds exported Swagger Info so clients can modify it +var SwaggerInfo = &swag.Spec{ + Version: "0.1", + Host: "localhost:8080", + BasePath: "/", + Schemes: []string{}, + Title: "RusPet Admin API", + Description: "API админ-панели для системы согласований\n\n## Возможности\n- Управление отделами, ролями и пользователями\n- Настройка тем и категорий согласований\n- Управление иерархией согласований\n- Назначение исполнителей и прав\n- Просмотр заявок и шагов согласования\n\n## Аутентификация\nВсе защищённые эндпоинты требуют:\n- `Authorization: Bearer ` — JWT токен администратора\n- `ApiKey: ` — HMAC подпись для верификации клиента\n- `X-Timestamp: ` — Unix timestamp (не старше 3 минут)\n- `x-device-id: ` — ID устройства", + InfoInstanceName: "swagger", + SwaggerTemplate: docTemplate, + LeftDelim: "{{", + RightDelim: "}}", +} + +func init() { + swag.Register(SwaggerInfo.InstanceName(), SwaggerInfo) +} + +-----END docs/docs.go----- + +File: handlers/admin/handlers.go +Lines: 502 +-----BEGIN handlers/admin/handlers.go----- +package adminhandler + +import ( + "bitrix_balancer_api/core/securecore" + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strings" +) + +// GetAdminsListHandler Получение списка администраторов +// @Summary Получение списка администраторов +// @Description Получение списка администраторов +// @Tags admin +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param is_active query boolean false "Фильтр по активности" +// @Success 200 {object} typescore.Admin "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/admin [get] +func (s *AdminsReg) GetAdminsListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + AdminsParams := &typescore.Admin{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, AdminsParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: AdminsParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + adminsDbLst, total, errW := s.ipc.Database.Admin.GetAdminsListDB(options) + if errW != nil { + return nil, errW + } + + ctx := r.Context() + for _, admin := range adminsDbLst { + if admin.TelegramID != nil { + telegramUser, err := s.ipc.Database.User.GetUserByTelegramIDDB(ctx, *admin.TelegramID) + if err == nil && telegramUser != nil { + admin.TelegramUser = telegramUser + } + } + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: adminsDbLst, + }, nil +} + +// CreateAdminHandler Создание администратора +func (s *AdminsReg) CreateAdminHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + // Проверка, что текущий админ — root + currentUserID, err := handlers.GetIDFromContext(r.Context()) + if err != nil { + return nil, errors.New("user not authenticated") + } + + currentAdmins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(currentAdmins) == 0 { + return nil, errors.New("current admin not found") + } + + if currentAdmins[0].IsRoot == nil || !*currentAdmins[0].IsRoot { + return nil, errors.New("only_root_can_create_admins") + } + + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req typescore.AdminReq + if err := json.Unmarshal(body, &req); err != nil { + return nil, err + } + + if req.Login == nil || *req.Login == "" { + return nil, errors.New("login is required") + } + + if req.IsObserver != nil && *req.IsObserver { + if req.TelegramID == nil { + return nil, errors.New("telegram_id_required_for_observer") + } + telegramUser, err := s.ipc.Database.User.GetUserByTelegramIDDB(r.Context(), *req.TelegramID) + if err != nil || telegramUser == nil { + return nil, errors.New("telegram_user_not_found") + } + } + + // Проверка уникальности логина + usersList, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{Login: req.Login}, + }) + if err != nil { + return nil, err + } + if len(usersList) > 0 { + return nil, errors.New("admin_is_not_available") + } + + tempPassword, err := utilscore.GenerateRandomString(12) + if err != nil { + return nil, err + } + + tempPasswordHash, err := securecore.HashPassword(&tempPassword) + if err != nil { + return nil, err + } + + newAdminObj := &typescore.Admin{ + Login: req.Login, + Name: req.Name, + PasswordHash: tempPasswordHash, + IsRoot: req.IsRoot, + IsObserver: req.IsObserver, + TelegramID: req.TelegramID, + } + + newAdmin, _, err := s.ipc.Database.Admin.CreateAdminDB(nil, newAdminObj, true) + if err != nil { + return nil, err + } + + newAdmin.Password = &tempPassword + + userID, err := handlers.GetIDFromContext(r.Context()) + if err != nil { + logrus.Errorf("Failed to get user id: %v", err) + } else { + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ + ID: &userID, + }, + }) + if err != nil { + logrus.Errorf("get admin list error: %v", err) + } + if len(admins) > 0 && admins[0] != nil { + snapshot := map[string]interface{}{ + "login": derefStr(newAdmin.Login), + "name": derefStr(newAdmin.Name), + "is_root": derefBool(newAdmin.IsRoot), + "is_observer": derefBool(newAdmin.IsObserver), + } + if newAdmin.TelegramID != nil { + snapshot["telegram_id"] = *newAdmin.TelegramID + } + + adminloghandler.LogAdminActionWithMetadata( + r.Context(), s.ipc, + *admins[0].ID, *admins[0].Login, + "create", "admin", newAdmin.ID, + fmt.Sprintf("Создан администратор «%s»", *newAdmin.Login), + map[string]interface{}{"snapshot": snapshot}, + ) + } + } + + return newAdmin, nil +} + +// UpdateAdminHandler Обновление администратора +func (s *AdminsReg) UpdateAdminHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req typescore.Admin + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("admin id is required") + } + + // Получаем существующего админа + existingAdmins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: req.ID}, + }) + if err != nil || len(existingAdmins) == 0 { + return nil, errors.New("admin not found") + } + existing := existingAdmins[0] + + // Получаем текущего админа + currentUserID, err := handlers.GetIDFromContext(r.Context()) + if err != nil { + return nil, errors.New("user not authenticated") + } + currentAdmins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(currentAdmins) == 0 { + return nil, errors.New("current admin not found") + } + currentIsRoot := currentAdmins[0].IsRoot != nil && *currentAdmins[0].IsRoot + + // Проверки root-прав (как было) + if req.IsRoot != nil { + if !currentIsRoot { + return nil, errors.New("only_root_can_manage_root_rights") + } + if *req.ID == currentUserID && !*req.IsRoot { + return nil, errors.New("cannot_remove_root_from_self") + } + if !*req.IsRoot && existing.IsRoot != nil && *existing.IsRoot { + allAdmins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{}, + }) + if err == nil { + rootCount := 0 + for _, a := range allAdmins { + if a.IsRoot != nil && *a.IsRoot { + rootCount++ + } + } + if rootCount <= 1 { + return nil, errors.New("cannot_remove_last_root") + } + } + } + } + + if req.IsBlocked != nil && *req.IsBlocked { + if existing.IsRoot != nil && *existing.IsRoot && !currentIsRoot { + return nil, errors.New("cannot_block_root") + } + } + + if *req.ID == currentUserID && req.IsBlocked != nil && *req.IsBlocked { + return nil, errors.New("cannot_block_self") + } + + isObserver := existing.IsObserver + telegramID := existing.TelegramID + + if req.IsObserver != nil { + isObserver = req.IsObserver + } + if req.TelegramID != nil { + telegramID = req.TelegramID + } + + if isObserver != nil && *isObserver { + if telegramID == nil { + return nil, errors.New("telegram_id_required_for_observer") + } + telegramUser, err := s.ipc.Database.User.GetUserByTelegramIDDB(r.Context(), *telegramID) + if err != nil || telegramUser == nil { + return nil, errors.New("telegram_user_not_found") + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.Name != nil && !strEq(existing.Name, req.Name) { + changes = append(changes, fieldChange{"name", derefStr(existing.Name), *req.Name}) + summary = append(summary, fmt.Sprintf("имя: «%s» → «%s»", derefStr(existing.Name), *req.Name)) + } + if req.IsBlocked != nil && !boolEq(existing.IsBlocked, req.IsBlocked) { + changes = append(changes, fieldChange{"is_blocked", derefBool(existing.IsBlocked), *req.IsBlocked}) + if *req.IsBlocked { + summary = append(summary, "заблокирован") + } else { + summary = append(summary, "разблокирован") + } + } + if req.IsRoot != nil && !boolEq(existing.IsRoot, req.IsRoot) { + changes = append(changes, fieldChange{"is_root", derefBool(existing.IsRoot), *req.IsRoot}) + if *req.IsRoot { + summary = append(summary, "выдана роль root") + } else { + summary = append(summary, "роль root снята") + } + } + if req.IsObserver != nil && !boolEq(existing.IsObserver, req.IsObserver) { + changes = append(changes, fieldChange{"is_observer", derefBool(existing.IsObserver), *req.IsObserver}) + if *req.IsObserver { + summary = append(summary, "включён режим наблюдателя") + } else { + summary = append(summary, "режим наблюдателя выключен") + } + } + if req.TelegramID != nil && !int64Eq(existing.TelegramID, req.TelegramID) { + var oldVal interface{} + if existing.TelegramID != nil { + oldVal = *existing.TelegramID + } + changes = append(changes, fieldChange{"telegram_id", oldVal, *req.TelegramID}) + summary = append(summary, fmt.Sprintf("telegram_id: %v → %d", oldVal, *req.TelegramID)) + } + + // Создаём объект для обновления + updateObj := &typescore.Admin{ + ID: req.ID, + } + if req.Name != nil { + updateObj.Name = req.Name + } + if req.IsBlocked != nil { + updateObj.IsBlocked = req.IsBlocked + } + if req.IsRoot != nil { + updateObj.IsRoot = req.IsRoot + } + if req.IsObserver != nil { + updateObj.IsObserver = req.IsObserver + } + if req.TelegramID != nil { + updateObj.TelegramID = req.TelegramID + } + + updated, _, err := s.ipc.Database.Admin.UpdateAdminDB(nil, updateObj, true) + if err != nil { + return nil, err + } + + // 🆕 Логируем ПОСЛЕ успешного обновления, и только если реально что-то + // изменилось (пустой запрос на обновление без факта изменений в + // журнал не пишем — иначе он будет засоряться). + if len(changes) > 0 { + description := fmt.Sprintf("Изменён администратор «%s»: %s", derefStr(existing.Login), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + r.Context(), s.ipc, + *currentAdmins[0].ID, *currentAdmins[0].Login, + "update", "admin", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + + return updated, nil +} + +// DeleteAdminHandler Удаление администратора +func (s *AdminsReg) DeleteAdminHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req typescore.Admin + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("admin id is required") + } + + // Нельзя удалить себя + currentUserID, err := handlers.GetIDFromContext(r.Context()) + if err != nil { + return nil, errors.New("user not authenticated") + } + if *req.ID == currentUserID { + return nil, errors.New("cannot_delete_self") + } + + // Получаем удаляемого админа + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: req.ID}, + }) + if err != nil || len(admins) == 0 { + return nil, errors.New("admin not found") + } + + // 🆕 Нельзя удалить root (если текущий не root) + currentAdmins, _, _ := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + currentIsRoot := len(currentAdmins) > 0 && currentAdmins[0].IsRoot != nil && *currentAdmins[0].IsRoot + + targetIsRoot := admins[0].IsRoot != nil && *admins[0].IsRoot + if targetIsRoot && !currentIsRoot { + return nil, errors.New("cannot_delete_root") + } + + // 🆕 Снапшот удаляемого администратора — берём ДО удаления (после + // DeleteAdminDB запись из БД уже не достать). + deletedSnapshot := map[string]interface{}{ + "login": derefStr(admins[0].Login), + "name": derefStr(admins[0].Name), + "is_root": derefBool(admins[0].IsRoot), + "is_observer": derefBool(admins[0].IsObserver), + } + if admins[0].TelegramID != nil { + deletedSnapshot["telegram_id"] = *admins[0].TelegramID + } + + err = s.ipc.Database.Admin.DeleteAdminDB(&req) + if err != nil { + return nil, err + } + + if len(currentAdmins) > 0 && currentAdmins[0] != nil { + adminloghandler.LogAdminActionWithMetadata( + r.Context(), s.ipc, + *currentAdmins[0].ID, *currentAdmins[0].Login, + "delete", "admin", req.ID, + fmt.Sprintf("Удалён администратор «%s»", derefStr(admins[0].Login)), + map[string]interface{}{"snapshot": deletedSnapshot}, + ) + } + + return true, nil +} + +// ============================================================ +// Небольшие помощники сравнения/разыменования — чтобы не плодить +// одинаковые проверки "оба nil или оба равны" по всему файлу. +// ============================================================ + +func derefStr(s *string) string { + if s == nil { + return "" + } + return *s +} + +func derefBool(b *bool) bool { + if b == nil { + return false + } + return *b +} + +func strEq(a, b *string) bool { + if a == nil && b == nil { + return true + } + if a == nil || b == nil { + return false + } + return *a == *b +} + +func boolEq(a, b *bool) bool { + if a == nil && b == nil { + return true + } + if a == nil || b == nil { + return false + } + return *a == *b +} + +func uint64Eq(a, b *uint64) bool { + if a == nil && b == nil { + return true + } + if a == nil || b == nil { + return false + } + return *a == *b +} + +func int64Eq(a, b *int64) bool { + if a == nil && b == nil { + return true + } + if a == nil || b == nil { + return false + } + return *a == *b +} + +-----END handlers/admin/handlers.go----- + +File: handlers/admin/routes.go +Lines: 38 +-----BEGIN handlers/admin/routes.go----- +package adminhandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "github.com/go-chi/chi/v5" + "net/http" +) + +const ( + adminURL = "/" +) + +type AdminsReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterAdminRoutes регистрирует маршруты для группы admin +func RegisterAdminRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &AdminsReg{ + ipc: ipc, + } + + r.Route("/api/admin", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, adminURL, s.GetAdminsListHandler) + handlers.RegisterRoute(r, http.MethodPost, adminURL, s.CreateAdminHandler) + handlers.RegisterRoute(r, http.MethodDelete, adminURL, s.DeleteAdminHandler) + handlers.RegisterRoute(r, http.MethodPut, adminURL, s.UpdateAdminHandler) + }) + + return nil +} + +-----END handlers/admin/routes.go----- + +File: handlers/admin_actions/handlers.go +Lines: 210 +-----BEGIN handlers/admin_actions/handlers.go----- +package adminloghandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "context" + "encoding/json" + "net/http" + "strconv" + "time" + + "github.com/go-chi/chi/v5" + "github.com/sirupsen/logrus" +) + +type AdminLogReg struct { + ipc *typesm.InternalProviderControl +} + +func RegisterAdminLogRoutes(r chi.Router, ipc *typesm.InternalProviderControl) error { + s := &AdminLogReg{ipc: ipc} + + r.Route("/api/admin-logs", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + handlers.RegisterRoute(r, http.MethodGet, "/", s.ListLogsHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/{id}", s.DeleteLogEntryHandler) + }) + + return nil +} + +// ListLogsHandler — теперь поддерживает: +// +// admin_id, admin_login (ILIKE), action, entity_type, entity_id, +// date_from, date_to (YYYY-MM-DD, включительно на весь день), +// search (ILIKE по description) +func (s *AdminLogReg) ListLogsHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + q := r.URL.Query() + + filter := typescore.AdminActionLogFilter{} + + if v := q.Get("admin_id"); v != "" { + if id, err := strconv.ParseUint(v, 10, 64); err == nil { + filter.AdminID = &id + } + } + if v := q.Get("admin_login"); v != "" { + filter.AdminLogin = &v + } + if v := q.Get("action"); v != "" { + filter.Action = &v + } + if v := q.Get("entity_type"); v != "" { + filter.EntityType = &v + } + if v := q.Get("entity_id"); v != "" { + if id, err := strconv.ParseUint(v, 10, 64); err == nil { + filter.EntityID = &id + } + } + if v := q.Get("date_from"); v != "" { + if t, err := time.Parse("2006-01-02", v); err == nil { + filter.DateFrom = &t + } + } + if v := q.Get("date_to"); v != "" { + if t, err := time.Parse("2006-01-02", v); err == nil { + endOfDay := t.Add(24*time.Hour - time.Second) + filter.DateTo = &endOfDay + } + } + if v := q.Get("search"); v != "" { + filter.Search = &v + } + + limit := parseUintPtr(q.Get("limit"), 50) + offset := parseUintPtr(q.Get("offset"), 0) + + logs, totalCount, err := s.ipc.Database.AdminActionLogs.GetAdminActionLogsFilteredDB(ctx, filter, offset, limit) + if err != nil { + return nil, err + } + + return map[string]interface{}{ + "data": logs, + "total_count": totalCount, + }, nil +} + +// DeleteLogEntryHandler — 🩹 восстановлена проверка is_root, потерянная +// в промежуточной версии. Удалять записи журнала может только +// root-администратор — без этой проверки endpoint открыт любому админу, +// что сводит на нет саму цель журнала (неизменяемость для всех, кроме root). +func (s *AdminLogReg) DeleteLogEntryHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + currentAdmin, ok := GetCurrentAdmin(ctx, s.ipc) + if !ok { + http.Error(w, "unauthorized", http.StatusUnauthorized) + return nil, nil + } + if currentAdmin.IsRoot == nil || !*currentAdmin.IsRoot { + http.Error(w, "только root-администратор может удалять записи журнала", http.StatusForbidden) + return nil, nil + } + + id, err := strconv.ParseUint(chi.URLParam(r, "id"), 10, 64) + if err != nil { + return nil, err + } + + if err := s.ipc.Database.AdminActionLogs.DeleteAdminActionLogDB(ctx, &typescore.AdminActionLog{ID: &id}); err != nil { + return nil, err + } + + return map[string]interface{}{"success": true}, nil +} + +func LogAdminAction( + ctx context.Context, + ipc *typesm.InternalProviderControl, + adminID uint64, + adminLogin string, + action string, + entityType string, + entityID *uint64, + description string, +) { + LogAdminActionWithMetadata(ctx, ipc, adminID, adminLogin, action, entityType, entityID, description, nil) +} + +func LogAdminActionWithMetadata( + ctx context.Context, + ipc *typesm.InternalProviderControl, + adminID uint64, + adminLogin string, + action string, + entityType string, + entityID *uint64, + description string, + metadata map[string]interface{}, +) { + var metadataJSON *string + if metadata != nil { + if b, err := json.Marshal(metadata); err == nil { + s := string(b) + metadataJSON = &s + } else { + logrus.Warnf("LogAdminActionWithMetadata: не удалось сериализовать metadata: %v", err) + } + } + + now := time.Now() + entry := &typescore.AdminActionLog{ + AdminID: &adminID, + AdminLogin: &adminLogin, + Action: &action, + EntityType: &entityType, + EntityID: entityID, + Description: &description, + Metadata: metadataJSON, + CreatedAt: &now, + } + + if _, _, err := ipc.Database.AdminActionLogs.CreateAdminActionLogDB(ctx, nil, entry); err != nil { + logrus.Errorf("LogAdminActionWithMetadata: не удалось записать в журнал (admin=%s, action=%s, entity=%s:%v): %v", + adminLogin, action, entityType, entityID, err) + } +} + +// GetCurrentAdmin — 🆕 вынесено сюда из 13 хендлеров, где было +// продублировано один в один под именем getCurrentAdmin (локальная, +// неэкспортируемая версия в каждом пакете отдельно). Экспортируемая +// версия здесь, в "родном" пакете журнала — логичное место, раз уже +// каждый из этих 13 хендлеров и так импортирует adminloghandler ради +// LogAdminActionWithMetadata. +// +// Миграция существующих хендлеров не обязательна прямо сейчас (все они +// рабочие как есть, с локальными копиями) — но при следующей правке +// любого из них имеет смысл заменить его локальный getCurrentAdmin на +// вызов adminloghandler.GetCurrentAdmin(ctx, s.ipc) и удалить дубликат. +func GetCurrentAdmin(ctx context.Context, ipc *typesm.InternalProviderControl) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +func parseUintPtr(v string, fallback uint64) *uint64 { + if v == "" { + return &fallback + } + n, err := strconv.ParseUint(v, 10, 64) + if err != nil { + return &fallback + } + return &n +} + +-----END handlers/admin_actions/handlers.go----- + +File: handlers/approval_steps/handlers.go +Lines: 442 +-----BEGIN handlers/approval_steps/handlers.go----- +package approvalstepshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "context" + "encoding/json" + "errors" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + + "github.com/go-chi/chi/v5" +) + +// GetApprovalStepsListHandler Получение списка шагов согласования +// @Summary Получение списка шагов +// @Description Получение списка шагов согласования с пагинацией и фильтрацией +// @Tags approval-steps +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param approval_id query integer false "Фильтр по заявке" +// @Param approver_id query integer false "Фильтр по согласующему" +// @Param status query string false "Фильтр по статусу (pending, waiting, approved, rejected, cancelled_any_of)" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approval-steps [get] +func (s *ApprovalStepsReg) GetApprovalStepsListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + stepParams := &typescore.ApprovalStep{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, stepParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: stepParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + stepsDbLst, total, errW := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(r.Context(), options) + if errW != nil { + return nil, errW + } + + // 🚀 Подгружаем связанные данные + for _, step := range stepsDbLst { + s.enrichStep(r.Context(), step, false) + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: stepsDbLst, + }, nil +} + +// GetApprovalStepByIDHandler Получение шага по ID +// @Summary Получение шага по ID +// @Description Получение детальной информации о шаге согласования по его ID +// @Tags approval-steps +// @Accept json +// @Produce json +// @Param id path integer true "ID шага" +// @Success 200 {object} typescore.ApprovalStep "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Шаг не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approval-steps/{id} [get] +func (s *ApprovalStepsReg) GetApprovalStepByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("step id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid step id") + } + + steps, _, err := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(r.Context(), typescore.ListDbOptions{ + Filtering: &typescore.ApprovalStep{ID: &id}, + }) + if err != nil { + return nil, err + } + if len(steps) == 0 { + return nil, errors.New("approval step not found") + } + + step := steps[0] + s.enrichStep(r.Context(), step, true) + + return step, nil +} + +// GetStepsByApprovalIDHandler Получение всех шагов для заявки +// @Summary Получение шагов по заявке +// @Description Получение списка всех шагов согласования для указанной заявки, отсортированных по step_order +// @Tags approval-steps +// @Accept json +// @Produce json +// @Param approval_id path integer true "ID заявки" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Заявка не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approval-steps/by-approval/{approval_id} [get] +func (s *ApprovalStepsReg) GetStepsByApprovalIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + approvalIDStr := chi.URLParam(r, "approval_id") + if approvalIDStr == "" { + return nil, errors.New("approval_id is required") + } + + approvalID, err := strconv.ParseUint(approvalIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid approval_id") + } + + // Проверяем, что заявка существует + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(r.Context(), approvalID) + if err != nil { + return nil, err + } + if approval == nil { + return nil, errors.New("approval not found") + } + + steps, _, err := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(r.Context(), typescore.ListDbOptions{ + Filtering: &typescore.ApprovalStep{ApprovalID: &approvalID}, + }) + if err != nil { + return nil, err + } + + // Сортируем по step_order + sortStepsByOrder(steps) + + // Подгружаем связанные данные + for _, step := range steps { + s.enrichStep(r.Context(), step, false) + } + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(steps)), + Data: steps, + }, nil +} + +// CreateApprovalStepHandler Создание шага согласования +// @Summary Создание шага +// @Description Создание нового шага согласования для заявки +// @Tags approval-steps +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalStep true "Данные шага" +// @Success 200 {object} typescore.ApprovalStep "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Заявка или согласующий не найдены" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approval-steps [post] +func (s *ApprovalStepsReg) CreateApprovalStepHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreateApprovalStepHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalStep + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + // Валидация обязательных полей + if req.ApprovalID == nil { + return nil, errors.New("approval_id is required") + } + if req.ApproverID == nil { + return nil, errors.New("approver_id is required") + } + if req.StepOrder == nil { + return nil, errors.New("step_order is required") + } + + ctx := r.Context() + + // Проверяем существование заявки + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, *req.ApprovalID) + if err != nil { + return nil, err + } + if approval == nil { + return nil, errors.New("approval not found") + } + + // 🛡 Можно добавлять шаги только к заявкам в статусе pending + if approval.Status == nil || *approval.Status != "pending" { + return nil, errors.New("can only add steps to pending approvals") + } + + // Проверяем существование согласующего + approver, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.ApproverID) + if err != nil { + return nil, err + } + if approver == nil { + return nil, errors.New("approver user not found") + } + + // Проверяем, что пользователь не заблокирован и не уволен + if approver.IsBlocked != nil && *approver.IsBlocked { + return nil, errors.New("approver user is blocked") + } + if approver.IsFired != nil && *approver.IsFired { + return nil, errors.New("approver user is fired") + } + + // Устанавливаем значения по умолчанию + if req.Status == nil { + defaultStatus := "waiting" + req.Status = &defaultStatus + } + + // Создаём снимок имени согласующего + if approver.FullName != nil && req.ApproverNameSnapshot == nil { + req.ApproverNameSnapshot = approver.FullName + } + + createdStep, _, err := s.ipc.Database.ApprovalStep.CreateApprovalStepDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichStep(ctx, createdStep, false) + + return createdStep, nil +} + +// UpdateApprovalStepHandler Обновление шага +// @Summary Обновление шага +// @Description Обновление данных шага согласования (статус, комментарий) +// @Tags approval-steps +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalStep true "Данные шага" +// @Success 200 {object} typescore.ApprovalStep "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Шаг не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approval-steps [put] +func (s *ApprovalStepsReg) UpdateApprovalStepHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateApprovalStepHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalStep + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("step id is required") + } + + ctx := r.Context() + + // Проверяем, что шаг существует + existingSteps, _, err := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalStep{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingSteps) == 0 { + return nil, errors.New("approval step not found") + } + existing := existingSteps[0] + + // 🛡 Если обновляется статус — проверяем валидность перехода + if req.Status != nil && existing.Status != nil { + if !isValidStepStatusTransition(*existing.Status, *req.Status) { + return nil, errors.New("invalid status transition from " + *existing.Status + " to " + *req.Status) + } + } + + updatedStep, _, err := s.ipc.Database.ApprovalStep.UpdateApprovalStepDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichStep(ctx, updatedStep, false) + + return updatedStep, nil +} + +// DeleteApprovalStepHandler Удаление шага +// @Summary Удаление шага +// @Description Удаление шага согласования (только для заявок в статусе pending) +// @Tags approval-steps +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalStep true "ID шага для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 403 {object} handlers.ErrorResponse "Нельзя удалить шаг завершённой заявки" +// @Failure 404 {object} handlers.ErrorResponse "Шаг не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approval-steps [delete] +func (s *ApprovalStepsReg) DeleteApprovalStepHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteApprovalStepHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalStep + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("step id is required") + } + + ctx := r.Context() + + // Проверяем, что шаг существует + existingSteps, _, err := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalStep{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingSteps) == 0 { + return nil, errors.New("approval step not found") + } + existing := existingSteps[0] + + // Проверяем заявку + if existing.ApprovalID != nil { + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, *existing.ApprovalID) + if err != nil { + return nil, err + } + if approval == nil { + return nil, errors.New("approval not found") + } + + // 🛡 Можно удалять шаги только у заявок в статусе pending + if approval.Status == nil || *approval.Status != "pending" { + return nil, errors.New("can only delete steps from pending approvals") + } + } + + // 🛡 Нельзя удалять уже обработанные шаги + if existing.Status != nil { + if *existing.Status == "approved" || *existing.Status == "rejected" { + return nil, errors.New("cannot delete completed steps") + } + } + + err = s.ipc.Database.ApprovalStep.DeleteApprovalStepDB(ctx, &req) + if err != nil { + return nil, err + } + + return true, nil +} + +// enrichStep подгружает связанные данные для шага +func (s *ApprovalStepsReg) enrichStep(ctx context.Context, step *typescore.ApprovalStep, loadApproval bool) { + if step == nil { + return + } + + // Подгружаем согласующего + if step.ApproverID != nil { + approver, err := s.ipc.Database.User.GetUserByIDDB(ctx, *step.ApproverID) + if err == nil && approver != nil { + step.Approver = approver + } + } + + // Подгружаем заявку (только для детального просмотра) + if loadApproval && step.ApprovalID != nil { + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, *step.ApprovalID) + if err == nil && approval != nil { + step.Approval = approval + } + } +} + +// sortStepsByOrder сортирует шаги по step_order +func sortStepsByOrder(steps []*typescore.ApprovalStep) { + for i := 0; i < len(steps); i++ { + for j := i + 1; j < len(steps); j++ { + if steps[i].StepOrder != nil && steps[j].StepOrder != nil { + if *steps[i].StepOrder > *steps[j].StepOrder { + steps[i], steps[j] = steps[j], steps[i] + } + } + } + } +} + +// isValidStepStatusTransition проверяет валидность перехода между статусами шага +func isValidStepStatusTransition(from, to string) bool { + validTransitions := map[string][]string{ + "pending": {"approved", "rejected", "cancelled_any_of"}, + "waiting": {"pending", "cancelled_any_of"}, + "approved": {}, // финальный статус + "rejected": {}, // финальный статус + "cancelled_any_of": {}, // финальный статус + } + + allowed, exists := validTransitions[from] + if !exists { + return false + } + + for _, status := range allowed { + if status == to { + return true + } + } + + return false +} + +-----END handlers/approval_steps/handlers.go----- + +File: handlers/approval_steps/routes.go +Lines: 43 +-----BEGIN handlers/approval_steps/routes.go----- +package approvalstepshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type ApprovalStepsReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterApprovalStepRoutes регистрирует маршруты для группы approval-steps +func RegisterApprovalStepRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &ApprovalStepsReg{ + ipc: ipc, + } + + r.Route("/api/approval-steps", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetApprovalStepsListHandler) + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateApprovalStepHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateApprovalStepHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteApprovalStepHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetApprovalStepByIDHandler, + })) + + r.Get("/by-approval/{approval_id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetStepsByApprovalIDHandler, + })) + }) + + return nil +} + +-----END handlers/approval_steps/routes.go----- + +File: handlers/approval_tasks/handlers.go +Lines: 518 +-----BEGIN handlers/approval_tasks/handlers.go----- +package approvaltaskshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "path/filepath" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" + "github.com/sirupsen/logrus" +) + +// GetApprovalTasksListHandler Получение списка задач +func (s *ApprovalTasksReg) GetApprovalTasksListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + taskParams := &typescore.ApprovalTask{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, taskParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: taskParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + tasks, total, errW := s.ipc.Database.ApprovalTasks.GetApprovalTasksListDB(ctx, options) + if errW != nil { + return nil, errW + } + + for _, task := range tasks { + s.enrichTask(ctx, task) + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: tasks, + }, nil +} + +// GetApprovalTaskByIDHandler Получение задачи по ID +func (s *ApprovalTasksReg) GetApprovalTaskByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("task id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid task id") + } + + ctx := r.Context() + task, err := s.ipc.Database.ApprovalTasks.GetApprovalTaskByIDDB(ctx, id) + if err != nil { + return nil, err + } + if task == nil { + return nil, errors.New("task not found") + } + + s.enrichTask(ctx, task) + + return task, nil +} + +// UpdateApprovalTaskHandler Обновление задачи +func (s *ApprovalTasksReg) UpdateApprovalTaskHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateApprovalTaskHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTask + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("task id is required") + } + + ctx := r.Context() + + // Проверяем существование + existingTask, err := s.ipc.Database.ApprovalTasks.GetApprovalTaskByIDDB(ctx, *req.ID) + if err != nil || existingTask == nil { + return nil, errors.New("task not found") + } + + if req.Status != nil { + validStatuses := map[string]bool{ + "pending": true, + "waiting": true, + "completed": true, + "cancelled": true, + } + if !validStatuses[*req.Status] { + return nil, errors.New("invalid status") + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.Status != nil && !utilscore.StrEq(existingTask.Status, req.Status) { + changes = append(changes, fieldChange{"status", utilscore.DerefStr(existingTask.Status), *req.Status}) + summary = append(summary, fmt.Sprintf("статус: «%s» → «%s»", utilscore.DerefStr(existingTask.Status), *req.Status)) + } + if req.TaskText != nil && !utilscore.StrEq(existingTask.TaskText, req.TaskText) { + changes = append(changes, fieldChange{"task_text", utilscore.DerefStr(existingTask.TaskText), *req.TaskText}) + summary = append(summary, "изменён текст задачи") + } + if req.ExecutorID != nil && !utilscore.Uint64Eq(existingTask.ExecutorID, req.ExecutorID) { + var oldVal interface{} + if existingTask.ExecutorID != nil { + oldVal = *existingTask.ExecutorID + } + changes = append(changes, fieldChange{"executor_id", oldVal, *req.ExecutorID}) + summary = append(summary, fmt.Sprintf("исполнитель: %v → %d", oldVal, *req.ExecutorID)) + } + if req.RequireFile != nil && !utilscore.BoolEq(existingTask.RequireFile, req.RequireFile) { + changes = append(changes, fieldChange{"require_file", utilscore.DerefBool(existingTask.RequireFile), *req.RequireFile}) + if *req.RequireFile { + summary = append(summary, "включено обязательное вложение файла") + } else { + summary = append(summary, "отключено обязательное вложение файла") + } + } + if req.StepOrder != nil && !utilscore.IntEq(existingTask.StepOrder, req.StepOrder) { + var oldVal interface{} + if existingTask.StepOrder != nil { + oldVal = *existingTask.StepOrder + } + changes = append(changes, fieldChange{"step_order", oldVal, *req.StepOrder}) + summary = append(summary, fmt.Sprintf("порядок шага: %v → %d", oldVal, *req.StepOrder)) + } + + updated, _, err := s.ipc.Database.ApprovalTasks.UpdateApprovalTaskDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichTask(ctx, updated) + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + approvalRef := "" + if existingTask.ApprovalID != nil { + approvalRef = fmt.Sprintf(" (заявка #%d)", *existingTask.ApprovalID) + } + description := fmt.Sprintf("Изменена задача #%d%s: %s", *req.ID, approvalRef, strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "approval_task", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return updated, nil +} + +// DeleteApprovalTaskHandler Удаление задачи +func (s *ApprovalTasksReg) DeleteApprovalTaskHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req typescore.ApprovalTask + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("task id is required") + } + + ctx := r.Context() + + existingTask, err := s.ipc.Database.ApprovalTasks.GetApprovalTaskByIDDB(ctx, *req.ID) + if err != nil || existingTask == nil { + return nil, errors.New("task not found") + } + snapshot := map[string]interface{}{ + "task_text": utilscore.DerefStr(existingTask.TaskText), + "status": utilscore.DerefStr(existingTask.Status), + "require_file": utilscore.DerefBool(existingTask.RequireFile), + } + if existingTask.ApprovalID != nil { + snapshot["approval_id"] = *existingTask.ApprovalID + } + if existingTask.ExecutorID != nil { + snapshot["executor_id"] = *existingTask.ExecutorID + } + if existingTask.StepOrder != nil { + snapshot["step_order"] = *existingTask.StepOrder + } + + err = s.ipc.Database.ApprovalTasks.DeleteApprovalTaskDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + approvalRef := "" + if existingTask.ApprovalID != nil { + approvalRef = fmt.Sprintf(" (заявка #%d)", *existingTask.ApprovalID) + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "approval_task", req.ID, + fmt.Sprintf("Удалена задача #%d%s", *req.ID, approvalRef), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func (s *ApprovalTasksReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + logrus.Warnf("getCurrentAdmin: GetIDFromContext err=%v", err) + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + logrus.Warnf("getCurrentAdmin: admin not found for userID=%d err=%v", currentUserID, err) + return nil, false + } + + return admins[0], true +} + +// enrichTask подгружает связанные данные для задачи +func (s *ApprovalTasksReg) enrichTask(ctx context.Context, task *typescore.ApprovalTask) { + if task == nil { + return + } + + // Подгружаем заявку + if task.ApprovalID != nil { + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, *task.ApprovalID) + if err == nil && approval != nil { + task.Approval = approval + s.enrichApproval(ctx, approval) + } + } + + // Подгружаем исполнителя + if task.ExecutorID != nil { + executor, err := s.ipc.Database.User.GetUserByIDDB(ctx, *task.ExecutorID) + if err == nil && executor != nil { + task.Executor = executor + if executor.DepartmentID != nil { + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *executor.DepartmentID) + if err == nil && department != nil { + executor.Department = department + } + } + } + } + + if task.ID != nil { + files, err := s.ipc.Database.ApprovalFile.GetFilesByTaskIDDB(ctx, *task.ID) + if err == nil { + task.Files = files + } + } +} + +func (s *ApprovalTasksReg) enrichApproval(ctx context.Context, approval *typescore.Approval) { + if approval == nil { + return + } + + // Подгружаем инициатора + if approval.InitiatorID != nil { + initiator, err := s.ipc.Database.User.GetUserByIDDB(ctx, *approval.InitiatorID) + if err == nil && initiator != nil { + approval.Initiator = initiator + + // Подгружаем отдел инициатора + if initiator.DepartmentID != nil { + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *initiator.DepartmentID) + if err == nil && department != nil { + initiator.Department = department + } + } + } + } + + // Подгружаем тему + if approval.TopicID != nil { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *approval.TopicID) + if err == nil && topic != nil { + approval.Topic = topic + + // Подгружаем категорию темы + if topic.CategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *topic.CategoryID) + if err == nil && category != nil { + topic.Category = category + } + } + } + } + + // Подгружаем отдел + if approval.DepartmentID != nil { + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *approval.DepartmentID) + if err == nil && department != nil { + approval.Department = department + } + } +} + +// GetApprovalTaskFileHandler Получение файла задачи (для предпросмотра) +// +// 🆕 Не логирую просмотр/скачивание файлов — журнал задуман под +// create/update/delete-действия, а не под чтение. Если захотите отслеживать +// ещё и скачивания (например, для файлов с чувствительными данными) — это +// отдельное решение, скажите, добавлю action="download" по тому же паттерну. +func (s *ApprovalTasksReg) GetApprovalTaskFileHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + taskIDStr := chi.URLParam(r, "task_id") + fileIDStr := chi.URLParam(r, "file_id") + + if taskIDStr == "" || fileIDStr == "" { + return nil, errors.New("task_id and file_id are required") + } + + taskID, err := strconv.ParseUint(taskIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid task_id") + } + + fileID, err := strconv.ParseUint(fileIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid file_id") + } + + // Проверяем, что задача существует + task, err := s.ipc.Database.ApprovalTasks.GetApprovalTaskByIDDB(ctx, taskID) + if err != nil || task == nil { + return nil, errors.New("task not found") + } + + // Получаем файл + file, err := s.ipc.Database.ApprovalFile.GetApprovalFileByIDDB(ctx, fileID) + if err != nil || file == nil { + return nil, errors.New("file not found") + } + + // Проверяем, что файл принадлежит задаче + if file.TaskID == nil || *file.TaskID != taskID { + return nil, errors.New("file does not belong to this task") + } + + if file.FileBase64 == nil || *file.FileBase64 == "" { + return nil, errors.New("file content is empty") + } + + fileData, err := base64.StdEncoding.DecodeString(*file.FileBase64) + if err != nil { + return nil, errors.New("failed to decode file") + } + + fileName := "" + if file.FileName != nil { + fileName = *file.FileName + } + mimeType := getMimeType(fileName) + + w.Header().Set("Content-Type", mimeType) + w.Header().Set("Content-Disposition", fmt.Sprintf(`inline; filename="%s"`, fileName)) + w.Header().Set("Content-Length", fmt.Sprintf("%d", len(fileData))) + w.Header().Set("Cache-Control", "public, max-age=31536000") + + w.WriteHeader(http.StatusOK) + _, err = w.Write(fileData) + if err != nil { + return nil, errors.New("failed to send file") + } + + return nil, nil +} + +// DownloadApprovalTaskFileHandler Скачивание файла задачи +func (s *ApprovalTasksReg) DownloadApprovalTaskFileHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + taskIDStr := chi.URLParam(r, "task_id") + fileIDStr := chi.URLParam(r, "file_id") + + if taskIDStr == "" || fileIDStr == "" { + return nil, errors.New("task_id and file_id are required") + } + + taskID, err := strconv.ParseUint(taskIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid task_id") + } + + fileID, err := strconv.ParseUint(fileIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid file_id") + } + + task, err := s.ipc.Database.ApprovalTasks.GetApprovalTaskByIDDB(ctx, taskID) + if err != nil || task == nil { + return nil, errors.New("task not found") + } + + file, err := s.ipc.Database.ApprovalFile.GetApprovalFileByIDDB(ctx, fileID) + if err != nil || file == nil { + return nil, errors.New("file not found") + } + + if file.TaskID == nil || *file.TaskID != taskID { + return nil, errors.New("file does not belong to this task") + } + + if file.FileBase64 == nil || *file.FileBase64 == "" { + return nil, errors.New("file content is empty") + } + + fileData, err := base64.StdEncoding.DecodeString(*file.FileBase64) + if err != nil { + return nil, errors.New("failed to decode file") + } + + fileName := "" + if file.FileName != nil { + fileName = *file.FileName + } + mimeType := getMimeType(fileName) + + w.Header().Set("Content-Type", mimeType) + w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, fileName)) + w.Header().Set("Content-Length", fmt.Sprintf("%d", len(fileData))) + + w.WriteHeader(http.StatusOK) + _, err = w.Write(fileData) + if err != nil { + return nil, errors.New("failed to send file") + } + + return nil, nil +} + +// 🆕 getMimeType определяет MIME тип по расширению файла +func getMimeType(fileName string) string { + ext := strings.ToLower(filepath.Ext(fileName)) + + mimeTypes := map[string]string{ + ".jpg": "image/jpeg", + ".jpeg": "image/jpeg", + ".png": "image/png", + ".gif": "image/gif", + ".webp": "image/webp", + ".svg": "image/svg+xml", + ".bmp": "image/bmp", + ".pdf": "application/pdf", + ".txt": "text/plain", + ".doc": "application/msword", + ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + ".xls": "application/vnd.ms-excel", + ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", + ".csv": "text/csv", + ".zip": "application/zip", + ".json": "application/json", + ".xml": "application/xml", + ".html": "text/html", + ".mp3": "audio/mpeg", + ".mp4": "video/mp4", + } + + if mimeType, ok := mimeTypes[ext]; ok { + return mimeType + } + + return "application/octet-stream" +} + +-----END handlers/approval_tasks/handlers.go----- + +File: handlers/approval_tasks/routes.go +Lines: 44 +-----BEGIN handlers/approval_tasks/routes.go----- +package approvaltaskshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type ApprovalTasksReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterApprovalTasksRoutes регистрирует маршруты для группы approvals +func RegisterApprovalTasksRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &ApprovalTasksReg{ + ipc: ipc, + } + + r.Route("/api/approval-tasks", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetApprovalTasksListHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateApprovalTaskHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteApprovalTaskHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetApprovalTaskByIDHandler, + })) + r.Get("/{task_id}/files/{file_id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetApprovalTaskFileHandler, + })) + r.Get("/{task_id}/files/{file_id}/download", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.DownloadApprovalTaskFileHandler, + })) + }) + + return nil +} + +-----END handlers/approval_tasks/routes.go----- + +File: handlers/approvalextras/handler.go +Lines: 422 +-----BEGIN handlers/approvalextras/handler.go----- +package approvalextrashandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "errors" + "net/http" + "strconv" + "time" + + "github.com/go-chi/chi/v5" +) + +type ApprovalExtrasReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterApprovalExtrasRoutes регистрирует данные о заявке, которые НЕ +// хранятся прямо на самой Approval (или пока не отдаются в основном ответе +// GET /api/approvals/{id}) — доп. согласующие, комментарии, наблюдатели +// (вычисляются динамически по категории/теме, не хранимая связь) и активный +// запрос на отзыв. +// +// ⚠️ ВАЖНО: регистрируем через r.Get() с полными путями, а НЕ через +// r.Route("/api/approvals/{id}", ...). r.Route создаёт отдельный вложенный +// роутер, который занимает узел {id} целиком — из-за этого существующий +// GET /api/approvals/{id} (без суффикса) становится недостижим и отдаёт 404, +// хотя вложенные пути (/additional-approvers и т.п.) продолжают работать. +// Проверено эмпирически на реальном chi.Router — с r.Route ломается, с +// r.Get(полный путь) — нет. +func RegisterApprovalExtrasRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &ApprovalExtrasReg{ipc: ipc} + + r.Group(func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/api/approvals/{id}/additional-approvers", s.GetAdditionalApproversHandler) + handlers.RegisterRoute(r, http.MethodGet, "/api/approvals/{id}/comments", s.GetCommentsHandler) + handlers.RegisterRoute(r, http.MethodGet, "/api/approvals/{id}/observers", s.GetObserversHandler) + handlers.RegisterRoute(r, http.MethodGet, "/api/approvals/{id}/revocation-request", s.GetRevocationRequestHandler) + handlers.RegisterRoute(r, http.MethodGet, "/api/approvals/{id}/tasks", s.GetTasksHandler) + }) + + return nil +} + +func parseApprovalID(r *http.Request) (uint64, error) { + idStr := chi.URLParam(r, "id") + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return 0, errors.New("invalid approval id") + } + return id, nil +} + +func userName(u *typescore.User) string { + if u != nil && u.FullName != nil { + return *u.FullName + } + return "—" +} + +// ============================================================ +// GET /api/approvals/{id}/additional-approvers +// ============================================================ + +type additionalApproverDTO struct { + ID uint64 `json:"id"` + ApproverID uint64 `json:"approver_id"` + ApproverName string `json:"approver_name"` + Status string `json:"status"` + Comment string `json:"comment,omitempty"` + ActedAt *time.Time `json:"acted_at,omitempty"` +} + +func (s *ApprovalExtrasReg) GetAdditionalApproversHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + approvalID, err := parseApprovalID(r) + if err != nil { + return nil, err + } + ctx := r.Context() + + records, _, err := s.ipc.Database.ApprovalAdditionalApprover.GetApprovalAdditionalApproversListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalAdditionalApprover{ApprovalID: &approvalID}, + }) + if err != nil { + return nil, err + } + + result := make([]additionalApproverDTO, 0, len(records)) + for _, rec := range records { + if rec.ApproverID == nil { + continue + } + approver, _ := s.ipc.Database.User.GetUserByIDDB(ctx, *rec.ApproverID) + + dto := additionalApproverDTO{ + ApproverID: *rec.ApproverID, + ApproverName: userName(approver), + Status: "pending", + ActedAt: rec.ActedAt, + } + if rec.ID != nil { + dto.ID = *rec.ID + } + if rec.Status != nil { + dto.Status = *rec.Status + } + if rec.Comment != nil { + dto.Comment = *rec.Comment + } + result = append(result, dto) + } + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(result)), + Data: result, + }, nil +} + +// ============================================================ +// GET /api/approvals/{id}/comments +// ============================================================ + +type commentDTO struct { + ID uint64 `json:"id"` + UserID uint64 `json:"user_id"` + UserName string `json:"user_name"` + Comment string `json:"comment"` + CreatedAt *time.Time `json:"created_at,omitempty"` +} + +func (s *ApprovalExtrasReg) GetCommentsHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + approvalID, err := parseApprovalID(r) + if err != nil { + return nil, err + } + ctx := r.Context() + + records, _, err := s.ipc.Database.ApprovalComment.GetApprovalCommentsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalComment{ApprovalID: &approvalID}, + }) + if err != nil { + return nil, err + } + + result := make([]commentDTO, 0, len(records)) + for _, rec := range records { + dto := commentDTO{CreatedAt: rec.CreatedAt} + if rec.ID != nil { + dto.ID = *rec.ID + } + if rec.UserID != nil { + dto.UserID = *rec.UserID + user, _ := s.ipc.Database.User.GetUserByIDDB(ctx, *rec.UserID) + dto.UserName = userName(user) + } + if rec.Comment != nil { + dto.Comment = *rec.Comment + } + result = append(result, dto) + } + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(result)), + Data: result, + }, nil +} + +// ============================================================ +// GET /api/approvals/{id}/observers +// +// Наблюдатели НЕ хранятся как связь на самой заявке — они вычисляются по +// категории/теме через права (см. GetObserversForApprovalDB в +// telegram_service). Здесь та же логика: сначала получаем код категории +// темы этой заявки, затем спрашиваем БД. +// ============================================================ + +type observerDTO struct { + ID uint64 `json:"id"` + FullName string `json:"full_name"` +} + +func (s *ApprovalExtrasReg) GetObserversHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + approvalID, err := parseApprovalID(r) + if err != nil { + return nil, err + } + ctx := r.Context() + + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, approvalID) + if err != nil { + return nil, err + } + if approval == nil { + return nil, errors.New("approval not found") + } + + categoryCode := "" + if approval.TopicID != nil { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *approval.TopicID) + if err == nil && topic != nil && topic.CategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *topic.CategoryID) + if err == nil && category != nil && category.Code != nil { + categoryCode = *category.Code + } + } + } + + observers, err := s.ipc.Database.User.GetObserversForApprovalDB(ctx, categoryCode, approval.TopicID) + if err != nil { + return nil, err + } + + result := make([]observerDTO, 0, len(observers)) + for _, obs := range observers { + if obs.ID == nil { + continue + } + result = append(result, observerDTO{ + ID: *obs.ID, + FullName: userName(obs), + }) + } + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(result)), + Data: result, + }, nil +} + +// ============================================================ +// GET /api/approvals/{id}/revocation-request +// +// Возвращает {"data": null}, если активного (pending) запроса на отзыв нет — +// это нормальный случай для большинства заявок, не ошибка. +// ============================================================ + +type revocationApproverDTO struct { + ApproverID uint64 `json:"approver_id"` + ApproverName string `json:"approver_name"` + Status string `json:"status"` +} + +type revocationRequestDTO struct { + ID uint64 `json:"id"` + Status string `json:"status"` + Reason string `json:"reason,omitempty"` + RequestedByID uint64 `json:"requested_by_id"` + RequestedByName string `json:"requested_by_name"` + Approvers []revocationApproverDTO `json:"approvers"` +} + +func (s *ApprovalExtrasReg) GetRevocationRequestHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + approvalID, err := parseApprovalID(r) + if err != nil { + return nil, err + } + ctx := r.Context() + + request, err := s.ipc.Database.ApprovalRevocation.GetPendingRevocationRequestForApprovalDB(ctx, approvalID) + if err != nil { + return nil, err + } + if request == nil { + return &typescore.ApiResponseBase{Data: nil}, nil + } + + dto := revocationRequestDTO{Status: "pending"} + if request.ID != nil { + dto.ID = *request.ID + } + if request.Status != nil { + dto.Status = *request.Status + } + if request.Reason != nil { + dto.Reason = *request.Reason + } + if request.RequestedByID != nil { + dto.RequestedByID = *request.RequestedByID + requestedBy, _ := s.ipc.Database.User.GetUserByIDDB(ctx, *request.RequestedByID) + dto.RequestedByName = userName(requestedBy) + } + + if request.ID != nil { + approvers, err := s.ipc.Database.ApprovalRevocation.GetRevocationApproversByRequestIDDB(ctx, *request.ID) + if err == nil { + for _, a := range approvers { + if a.ApproverID == nil { + continue + } + approverUser, _ := s.ipc.Database.User.GetUserByIDDB(ctx, *a.ApproverID) + status := "pending" + if a.Status != nil { + status = *a.Status + } + dto.Approvers = append(dto.Approvers, revocationApproverDTO{ + ApproverID: *a.ApproverID, + ApproverName: userName(approverUser), + Status: status, + }) + } + } + } + + return &typescore.ApiResponseBase{Data: dto}, nil +} + +// ============================================================ +// GET /api/approvals/{id}/tasks +// +// Две вещи в одном ответе: +// - topic_executors — что НАСТРОЕНО для темы этой заявки (ApprovalTopicExecutor), +// нужно для превью "какие задачи будут поставлены после согласования" +// на pending-заявках, ещё до их фактического создания. +// - tasks — что РЕАЛЬНО создано (ApprovalTask), уже после согласования. +// - has_task_error — та же логика, что в отчёте (reportcore.BuildExcelApprovalsReport): +// если для темы настроены исполнители, заявка уже approved, а задач +// по факту нет — это ошибка на этапе создания задач, а не "не предусмотрено". +// ============================================================ + +type plannedTaskDTO struct { + ID uint64 `json:"id"` + TaskText string `json:"task_text"` + ExecutorName string `json:"executor_name,omitempty"` + StepOrder int `json:"step_order"` +} + +type taskDTO struct { + ID uint64 `json:"id"` + TaskText string `json:"task_text"` + ExecutorName string `json:"executor_name"` + Status string `json:"status"` + CompletedAt *time.Time `json:"completed_at,omitempty"` +} + +type approvalTasksResponse struct { + TopicExecutors []plannedTaskDTO `json:"topic_executors"` + Tasks []taskDTO `json:"tasks"` + HasTaskError bool `json:"has_task_error"` +} + +func (s *ApprovalExtrasReg) GetTasksHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + approvalID, err := parseApprovalID(r) + if err != nil { + return nil, err + } + ctx := r.Context() + + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, approvalID) + if err != nil { + return nil, err + } + if approval == nil { + return nil, errors.New("approval not found") + } + + resp := &approvalTasksResponse{} + + if approval.TopicID == nil { + return &typescore.ApiResponseBase{Data: resp}, nil + } + + topicExecutors, err := s.ipc.Database.ApprovalTopicExecutor.GetExecutorsByTopicIDDB(ctx, *approval.TopicID) + if err != nil { + return nil, err + } + + for _, te := range topicExecutors { + if te.ID == nil { + continue + } + dto := plannedTaskDTO{ID: *te.ID} + if te.TaskText != nil { + dto.TaskText = *te.TaskText + } + if te.StepOrder != nil { + dto.StepOrder = *te.StepOrder + } + if te.UserID != nil { + executor, _ := s.ipc.Database.User.GetUserByIDDB(ctx, *te.UserID) + dto.ExecutorName = userName(executor) + } + resp.TopicExecutors = append(resp.TopicExecutors, dto) + } + + tasks, _, err := s.ipc.Database.ApprovalTasks.GetApprovalTasksListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTask{ApprovalID: &approvalID}, + }) + if err != nil { + return nil, err + } + + for _, t := range tasks { + if t.ID == nil { + continue + } + dto := taskDTO{ID: *t.ID, Status: "—", CompletedAt: t.CompletedAt} + if t.TaskText != nil { + dto.TaskText = *t.TaskText + } + if t.Status != nil { + dto.Status = *t.Status + } + if t.ExecutorID != nil { + executor, _ := s.ipc.Database.User.GetUserByIDDB(ctx, *t.ExecutorID) + dto.ExecutorName = userName(executor) + } + resp.Tasks = append(resp.Tasks, dto) + } + + if len(topicExecutors) > 0 && len(tasks) == 0 && approval.Status != nil && *approval.Status == "approved" { + resp.HasTaskError = true + } + + return &typescore.ApiResponseBase{Data: resp}, nil +} + +-----END handlers/approvalextras/handler.go----- + +File: handlers/approvals/files.go +Lines: 278 +-----BEGIN handlers/approvals/files.go----- +package approvalshandler + +import ( + "bitrix_balancer_api/core/typescore" + "encoding/base64" + "fmt" + "net/http" + "path/filepath" + "strings" + + "github.com/go-chi/chi/v5" +) + +// GetApprovalFileHandler Получение файла заявки +// @Summary Получение файла заявки +// @Description Возвращает файл по ID заявки и ID файла +// @Tags approvals +// @Produce application/octet-stream +// @Param approval_id path integer true "ID заявки" +// @Param file_id path integer true "ID файла" +// @Success 200 {file} binary "Файл" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Файл не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals/{approval_id}/files/{file_id} [get] +func (s *ApprovalsReg) GetApprovalFileHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + // Получаем ID из URL + approvalIDStr := chi.URLParam(r, "approval_id") + fileIDStr := chi.URLParam(r, "file_id") + + if approvalIDStr == "" || fileIDStr == "" { + return nil, fmt.Errorf("approval_id and file_id are required") + } + + approvalID, err := parseUint64(approvalIDStr) + if err != nil { + return nil, fmt.Errorf("invalid approval_id: %w", err) + } + + fileID, err := parseUint64(fileIDStr) + if err != nil { + return nil, fmt.Errorf("invalid file_id: %w", err) + } + + // Получаем заявку + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, approvalID) + if err != nil { + return nil, fmt.Errorf("failed to get approval: %w", err) + } + if approval == nil { + return nil, fmt.Errorf("approval not found") + } + + // Ищем файл в заявке + var targetFile *typescore.ApprovalFile + if approval.Files != nil { + for i := range approval.Files { + if approval.Files[i].ID != nil && *approval.Files[i].ID == fileID { + targetFile = approval.Files[i] + break + } + } + } + + // Если файл не найден в кэше, загружаем все файлы заявки + if targetFile == nil { + files, err := s.ipc.Database.ApprovalFile.GetFilesByApprovalIDDB(ctx, approvalID) + if err != nil { + return nil, fmt.Errorf("failed to get files: %w", err) + } + + for i := range files { + if files[i].ID != nil && *files[i].ID == fileID { + targetFile = files[i] + break + } + } + } + + if targetFile == nil { + return nil, fmt.Errorf("file not found") + } + + // Проверяем, что файл существует + if targetFile.FileBase64 == nil || *targetFile.FileBase64 == "" { + return nil, fmt.Errorf("file content is empty") + } + + // Декодируем base64 + fileData, err := base64.StdEncoding.DecodeString(*targetFile.FileBase64) + if err != nil { + return nil, fmt.Errorf("failed to decode file: %w", err) + } + + // Определяем MIME тип + fileName := "" + if targetFile.FileName != nil { + fileName = *targetFile.FileName + } + mimeType := getMimeType(fileName) + + // Устанавливаем заголовки + w.Header().Set("Content-Type", mimeType) + w.Header().Set("Content-Disposition", fmt.Sprintf(`inline; filename="%s"`, fileName)) + w.Header().Set("Content-Length", fmt.Sprintf("%d", len(fileData))) + w.Header().Set("Cache-Control", "public, max-age=31536000") + + // Отправляем файл + w.WriteHeader(http.StatusOK) + _, err = w.Write(fileData) + if err != nil { + return nil, fmt.Errorf("failed to send file: %w", err) + } + + return nil, nil // nil означает, что мы уже отправили ответ +} + +// DownloadApprovalFileHandler Скачивание файла заявки +// @Summary Скачивание файла заявки +// @Description Скачивает файл по ID заявки и ID файла +// @Tags approvals +// @Produce application/octet-stream +// @Param approval_id path integer true "ID заявки" +// @Param file_id path integer true "ID файла" +// @Success 200 {file} binary "Файл" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Файл не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals/{approval_id}/files/{file_id}/download [get] +func (s *ApprovalsReg) DownloadApprovalFileHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + approvalIDStr := chi.URLParam(r, "approval_id") + fileIDStr := chi.URLParam(r, "file_id") + + if approvalIDStr == "" || fileIDStr == "" { + return nil, fmt.Errorf("approval_id and file_id are required") + } + + approvalID, err := parseUint64(approvalIDStr) + if err != nil { + return nil, fmt.Errorf("invalid approval_id: %w", err) + } + + fileID, err := parseUint64(fileIDStr) + if err != nil { + return nil, fmt.Errorf("invalid file_id: %w", err) + } + + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, approvalID) + if err != nil { + return nil, fmt.Errorf("failed to get approval: %w", err) + } + if approval == nil { + return nil, fmt.Errorf("approval not found") + } + + var targetFile *typescore.ApprovalFile + if approval.Files != nil { + for i := range approval.Files { + if approval.Files[i].ID != nil && *approval.Files[i].ID == fileID { + targetFile = approval.Files[i] + break + } + } + } + + if targetFile == nil { + files, err := s.ipc.Database.ApprovalFile.GetFilesByApprovalIDDB(ctx, approvalID) + if err != nil { + return nil, fmt.Errorf("failed to get files: %w", err) + } + + for i := range files { + if files[i].ID != nil && *files[i].ID == fileID { + targetFile = files[i] + break + } + } + } + + if targetFile == nil { + return nil, fmt.Errorf("file not found") + } + + if targetFile.FileBase64 == nil || *targetFile.FileBase64 == "" { + return nil, fmt.Errorf("file content is empty") + } + + fileData, err := base64.StdEncoding.DecodeString(*targetFile.FileBase64) + if err != nil { + return nil, fmt.Errorf("failed to decode file: %w", err) + } + + fileName := "" + if targetFile.FileName != nil { + fileName = *targetFile.FileName + } + mimeType := getMimeType(fileName) + + w.Header().Set("Content-Type", mimeType) + w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, fileName)) + w.Header().Set("Content-Length", fmt.Sprintf("%d", len(fileData))) + + w.WriteHeader(http.StatusOK) + _, err = w.Write(fileData) + if err != nil { + return nil, fmt.Errorf("failed to send file: %w", err) + } + + return nil, nil +} + +// getMimeType определяет MIME тип по расширению файла +func getMimeType(fileName string) string { + ext := strings.ToLower(filepath.Ext(fileName)) + + mimeTypes := map[string]string{ + // Images + ".jpg": "image/jpeg", + ".jpeg": "image/jpeg", + ".png": "image/png", + ".gif": "image/gif", + ".webp": "image/webp", + ".svg": "image/svg+xml", + ".bmp": "image/bmp", + ".ico": "image/x-icon", + + // PDF + ".pdf": "application/pdf", + + // Documents + ".txt": "text/plain", + ".doc": "application/msword", + ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + ".xls": "application/vnd.ms-excel", + ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", + ".csv": "text/csv", + + // Archives + ".zip": "application/zip", + ".rar": "application/vnd.rar", + ".7z": "application/x-7z-compressed", + ".tar": "application/x-tar", + ".gz": "application/gzip", + + // Code + ".json": "application/json", + ".xml": "application/xml", + ".html": "text/html", + ".css": "text/css", + ".js": "application/javascript", + + // Audio/Video + ".mp3": "audio/mpeg", + ".mp4": "video/mp4", + ".avi": "video/x-msvideo", + ".mov": "video/quicktime", + ".wmv": "video/x-ms-wmv", + ".flv": "video/x-flv", + ".webm": "video/webm", + } + + if mimeType, ok := mimeTypes[ext]; ok { + return mimeType + } + + return "application/octet-stream" +} + +// parseUint64 парсит строку в uint64 +func parseUint64(s string) (uint64, error) { + var result uint64 + _, err := fmt.Sscanf(s, "%d", &result) + return result, err +} + +-----END handlers/approvals/files.go----- + +File: handlers/approvals/handlers.go +Lines: 678 +-----BEGIN handlers/approvals/handlers.go----- +package approvalshandler + +import ( + "bitrix_balancer_api/core/typescore" + "context" + "encoding/json" + "errors" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + "sync" + "time" + + "github.com/go-chi/chi/v5" +) + +// GetApprovalsListHandler Получение списка заявок с расширенной фильтрацией +// @Summary Получение списка заявок +// @Description Получение списка заявок с пагинацией и расширенной фильтрацией +// @Tags approvals +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param status query string false "Фильтр по статусу" +// @Param initiator_id query integer false "Фильтр по инициатору" +// @Param topic_id query integer false "Фильтр по теме (одна)" +// @Param topic_ids query string false "Фильтр по темам (через запятую)" +// @Param category_ids query string false "Фильтр по категориям (через запятую)" +// @Param department_id query integer false "Фильтр по отделу" +// @Param date_from query string false "Начальная дата (YYYY-MM-DD)" +// @Param date_to query string false "Конечная дата (YYYY-MM-DD)" +// @Param content query string false "Поиск по тексту заявки" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals [get] +func (s *ApprovalsReg) GetApprovalsListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + filter := typescore.ApprovalFilter{} + + if status := queryParams.Get("status"); status != "" { + filter.Status = &status + } + if initiatorIDStr := queryParams.Get("initiator_id"); initiatorIDStr != "" { + id, err := strconv.ParseUint(initiatorIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid initiator_id") + } + filter.InitiatorID = &id + } + if departmentIDStr := queryParams.Get("department_id"); departmentIDStr != "" { + id, err := strconv.ParseUint(departmentIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid department_id") + } + filter.DepartmentID = &id + } + + contentSearch := queryParams.Get("content") + if contentSearch != "" { + if len(contentSearch) < 2 { + return nil, errors.New("search query must be at least 2 characters") + } + filter.Content = &contentSearch + } + + if topicIDsStr := queryParams.Get("topic_ids"); topicIDsStr != "" { + ids, err := parseUint64Array(topicIDsStr) + if err != nil { + return nil, errors.New("invalid topic_ids") + } + filter.TopicIDs = ids + } else if topicIDStr := queryParams.Get("topic_id"); topicIDStr != "" { + id, err := strconv.ParseUint(topicIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid topic_id") + } + filter.TopicIDs = []uint64{id} + } + + if categoryIDsStr := queryParams.Get("category_ids"); categoryIDsStr != "" { + ids, err := parseUint64Array(categoryIDsStr) + if err != nil { + return nil, errors.New("invalid category_ids") + } + filter.CategoryIDs = ids + } + + if dateFromStr := queryParams.Get("date_from"); dateFromStr != "" { + dateFrom, err := time.Parse("2006-01-02", dateFromStr) + if err != nil { + return nil, errors.New("invalid date_from format, use YYYY-MM-DD") + } + filter.DateFrom = &dateFrom + } + if dateToStr := queryParams.Get("date_to"); dateToStr != "" { + dateTo, err := time.Parse("2006-01-02", dateToStr) + if err != nil { + return nil, errors.New("invalid date_to format, use YYYY-MM-DD") + } + filter.DateTo = &dateTo + } + + offset := uint64(0) + limit := uint64(100) + if offsetStr := queryParams.Get("offset"); offsetStr != "" { + if v, err := strconv.ParseUint(offsetStr, 10, 64); err == nil { + offset = v + } + } + if limitStr := queryParams.Get("limit"); limitStr != "" { + if v, err := strconv.ParseUint(limitStr, 10, 64); err == nil { + limit = v + } + } + + ctx := r.Context() + + approvalsDbLst, total, errW := s.ipc.Database.Approval.GetApprovalsListFilteredDB(ctx, filter, offset, limit) + if errW != nil { + logrus.Errorf("❌ GetApprovalsListHandler error: %v", errW) + return nil, errW + } + + if approvalsDbLst == nil { + approvalsDbLst = []*typescore.Approval{} + } + + s.enrichApprovalsBatch(ctx, approvalsDbLst, false) + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: approvalsDbLst, + }, nil +} + +// parseUint64Array — парсит строку "1,2,3" в []uint64 +func parseUint64Array(s string) ([]uint64, error) { + parts := strings.Split(s, ",") + result := make([]uint64, 0, len(parts)) + for _, p := range parts { + p = strings.TrimSpace(p) + if p == "" { + continue + } + v, err := strconv.ParseUint(p, 10, 64) + if err != nil { + return nil, err + } + result = append(result, v) + } + return result, nil +} + +// GetApprovalByIDHandler Получение заявки по ID +// @Summary Получение заявки по ID +// @Description Получение детальной информации о заявке по её ID со всеми связанными данными +// @Tags approvals +// @Accept json +// @Produce json +// @Param id path integer true "ID заявки" +// @Success 200 {object} typescore.Approval "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Заявка не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals/{id} [get] +func (s *ApprovalsReg) GetApprovalByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("approval id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid approval id") + } + + ctx := r.Context() + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, id) + if err != nil { + return nil, err + } + if approval == nil { + return nil, errors.New("approval not found") + } + + // 🚀 Подгружаем все связанные данные + s.enrichApproval(ctx, approval, true) + + return approval, nil +} + +// UpdateApprovalHandler Обновление заявки +// @Summary Обновление заявки +// @Description Обновление данных заявки (статус, комментарии и т.д.) +// @Tags approvals +// @Accept json +// @Produce json +// @Param request body typescore.Approval true "Данные заявки" +// @Success 200 {object} typescore.Approval "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Заявка не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals [put] +func (s *ApprovalsReg) UpdateApprovalHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateApprovalHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Approval + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("approval id is required") + } + + ctx := r.Context() + + // Проверяем, что заявка существует + existingApproval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingApproval == nil { + return nil, errors.New("approval not found") + } + + // 🛡 Если обновляется статус — проверяем валидность перехода + if req.Status != nil && existingApproval.Status != nil { + if !isValidStatusTransition(*existingApproval.Status, *req.Status) { + return nil, errors.New("invalid status transition from " + *existingApproval.Status + " to " + *req.Status) + } + } + + updatedApproval, _, err := s.ipc.Database.Approval.UpdateApprovalDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichApproval(ctx, updatedApproval, true) + + return updatedApproval, nil +} + +// DeleteApprovalHandler Удаление заявки +// @Summary Удаление заявки +// @Description Удаление заявки (только для черновиков) +// @Tags approvals +// @Accept json +// @Produce json +// @Param request body typescore.Approval true "ID заявки для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 403 {object} handlers.ErrorResponse "Нельзя удалить не-черновую заявку" +// @Failure 404 {object} handlers.ErrorResponse "Заявка не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals [delete] +func (s *ApprovalsReg) DeleteApprovalHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteApprovalHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Approval + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("approval id is required") + } + + ctx := r.Context() + + // Проверяем, что заявка существует + existingApproval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingApproval == nil { + return nil, errors.New("approval not found") + } + + // 🛡 Можно удалять только черновики + if existingApproval.Status == nil || *existingApproval.Status != "draft" { + return nil, errors.New("only draft approvals can be deleted") + } + + err = s.ipc.Database.Approval.DeleteApprovalDB(ctx, &req) + if err != nil { + return nil, err + } + + return true, nil +} + +// GetApprovalsForReportHandler Получение заявок для отчёта +// @Summary Получение заявок для отчёта +// @Description Получение списка заявок для отчёта с учётом периода и доступа пользователя +// @Tags approvals +// @Accept json +// @Produce json +// @Param user_id query integer false "ID пользователя (если не указан - все заявки)" +// @Param date_from query string false "Начальная дата (YYYY-MM-DD)" +// @Param date_to query string false "Конечная дата (YYYY-MM-DD)" +// @Param all_access query boolean false "Полный доступ (игнорировать фильтрацию по пользователю)" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals/report [get] +func (s *ApprovalsReg) GetApprovalsForReportHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + filter := typescore.ReportFilter{} + + if userIDStr := queryParams.Get("user_id"); userIDStr != "" { + userID, err := strconv.ParseUint(userIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid user_id") + } + filter.UserID = &userID + } + + if dateFromStr := queryParams.Get("date_from"); dateFromStr != "" { + dateFrom, err := time.Parse("2006-01-02", dateFromStr) + if err != nil { + return nil, errors.New("invalid date_from format, use YYYY-MM-DD") + } + filter.DateFrom = &dateFrom + } + + if dateToStr := queryParams.Get("date_to"); dateToStr != "" { + dateTo, err := time.Parse("2006-01-02", dateToStr) + if err != nil { + return nil, errors.New("invalid date_to format, use YYYY-MM-DD") + } + filter.DateTo = &dateTo + } + + if allAccessStr := queryParams.Get("all_access"); allAccessStr == "true" { + filter.AllAccess = true + } + + ctx := r.Context() + approvals, err := s.ipc.Database.Approval.GetApprovalsForReportDB(ctx, filter) + if err != nil { + return nil, err + } + + s.enrichApprovalsBatch(ctx, approvals, false) + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(approvals)), + Data: approvals, + }, nil +} + +// enrichApproval подгружает связанные данные для заявки +// enrichApproval подгружает связанные данные для ОДНОЙ заявки. +// Независимые запросы выполняются параллельно, чтобы сократить суммарную задержку. +func (s *ApprovalsReg) enrichApproval(ctx context.Context, approval *typescore.Approval, loadSteps bool) { + if approval == nil { + return + } + + var wg sync.WaitGroup + + if approval.InitiatorID != nil { + wg.Add(1) + go func() { + defer wg.Done() + if initiator, err := s.ipc.Database.User.GetUserByIDDB(ctx, *approval.InitiatorID); err == nil && initiator != nil { + approval.Initiator = initiator + } + }() + } + + if approval.TopicID != nil { + wg.Add(1) + go func() { + defer wg.Done() + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *approval.TopicID) + if err == nil && topic != nil { + approval.Topic = topic + if topic.CategoryID != nil { + if category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *topic.CategoryID); err == nil && category != nil { + topic.Category = category + } + } + } + }() + } + + if approval.DepartmentID != nil { + wg.Add(1) + go func() { + defer wg.Done() + if department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *approval.DepartmentID); err == nil && department != nil { + approval.Department = department + } + }() + } + + if approval.RevokedByID != nil { + wg.Add(1) + go func() { + defer wg.Done() + if revokedBy, err := s.ipc.Database.User.GetUserByIDDB(ctx, *approval.RevokedByID); err == nil && revokedBy != nil { + approval.RevokedBy = revokedBy + } + }() + } + + if approval.ID != nil { + wg.Add(1) + go func() { + defer wg.Done() + if files, err := s.ipc.Database.ApprovalFile.GetFilesByApprovalIDDB(ctx, *approval.ID); err == nil { + approval.Files = files + } + }() + } + + if loadSteps && approval.ID != nil { + wg.Add(1) + go func() { + defer wg.Done() + steps, _, err := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalStep{ApprovalID: approval.ID}, + }) + if err != nil { + return + } + + // Согласующие подгружаются одним батч-запросом, а не по одному на шаг + approverIDsSet := make(map[uint64]struct{}) + for _, step := range steps { + if step.ApproverID != nil { + approverIDsSet[*step.ApproverID] = struct{}{} + } + } + approverIDs := make([]uint64, 0, len(approverIDsSet)) + for id := range approverIDsSet { + approverIDs = append(approverIDs, id) + } + + if approvers, err := s.ipc.Database.User.GetUsersByIDsDB(ctx, approverIDs); err == nil { + approversMap := make(map[uint64]*typescore.User, len(approvers)) + for _, u := range approvers { + if u.ID != nil { + approversMap[*u.ID] = u + } + } + for _, step := range steps { + if step.ApproverID != nil { + if approver, ok := approversMap[*step.ApproverID]; ok { + step.Approver = approver + } + } + } + } + + approval.Steps = steps + }() + } + + wg.Wait() +} + +// isValidStatusTransition проверяет валидность перехода между статусами +func isValidStatusTransition(from, to string) bool { + validTransitions := map[string][]string{ + "draft": {"pending", "approved", "rejected"}, + "pending": {"approved", "rejected", "revoked", "revision"}, + "approved": {"revoked", "revision"}, + "rejected": {"pending", "revision"}, + "revoked": {"pending"}, + "revision": {"pending"}, + } + + allowed, exists := validTransitions[from] + if !exists { + return false + } + + for _, status := range allowed { + if status == to { + return true + } + } + + return false +} + +// enrichApprovalsBatch выполняет пакетную подгрузку связанных данных для СПИСКА заявок, +// заменяя N+1 отдельных запросов (было: enrichApproval в цикле) несколькими батч-запросами. +func (s *ApprovalsReg) enrichApprovalsBatch(ctx context.Context, approvals []*typescore.Approval, loadSteps bool) { + if len(approvals) == 0 { + return + } + + userIDsSet := make(map[uint64]struct{}) + topicIDsSet := make(map[uint64]struct{}) + departmentIDsSet := make(map[uint64]struct{}) + approvalIDs := make([]uint64, 0, len(approvals)) + + for _, a := range approvals { + if a.InitiatorID != nil { + userIDsSet[*a.InitiatorID] = struct{}{} + } + if a.RevokedByID != nil { + userIDsSet[*a.RevokedByID] = struct{}{} + } + if a.TopicID != nil { + topicIDsSet[*a.TopicID] = struct{}{} + } + if a.DepartmentID != nil { + departmentIDsSet[*a.DepartmentID] = struct{}{} + } + if a.ID != nil { + approvalIDs = append(approvalIDs, *a.ID) + } + } + + userIDs := make([]uint64, 0, len(userIDsSet)) + for id := range userIDsSet { + userIDs = append(userIDs, id) + } + topicIDs := make([]uint64, 0, len(topicIDsSet)) + for id := range topicIDsSet { + topicIDs = append(topicIDs, id) + } + departmentIDs := make([]uint64, 0, len(departmentIDsSet)) + for id := range departmentIDsSet { + departmentIDs = append(departmentIDs, id) + } + + usersMap := make(map[uint64]*typescore.User) + if users, err := s.ipc.Database.User.GetUsersByIDsDB(ctx, userIDs); err == nil { + for _, u := range users { + if u.ID != nil { + usersMap[*u.ID] = u + } + } + } + + topicsMap := make(map[uint64]*typescore.ApprovalTopic) + categoryIDsSet := make(map[uint64]struct{}) + if topics, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsByIDsDB(ctx, topicIDs); err == nil { + for _, t := range topics { + if t.ID != nil { + topicsMap[*t.ID] = t + } + if t.CategoryID != nil { + categoryIDsSet[*t.CategoryID] = struct{}{} + } + } + } + + categoryIDs := make([]uint64, 0, len(categoryIDsSet)) + for id := range categoryIDsSet { + categoryIDs = append(categoryIDs, id) + } + categoriesMap := make(map[uint64]*typescore.ApprovalTopicCategory) + if categories, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoriesByIDsDB(ctx, categoryIDs); err == nil { + for _, c := range categories { + if c.ID != nil { + categoriesMap[*c.ID] = c + } + } + } + for _, t := range topicsMap { + if t.CategoryID != nil { + if cat, ok := categoriesMap[*t.CategoryID]; ok { + t.Category = cat + } + } + } + + departmentsMap := make(map[uint64]*typescore.Department) + if departments, err := s.ipc.Database.Department.GetDepartmentsByIDsDB(ctx, departmentIDs); err == nil { + for _, d := range departments { + if d.ID != nil { + departmentsMap[*d.ID] = d + } + } + } + + filesMap := make(map[uint64][]*typescore.ApprovalFile) + if files, err := s.ipc.Database.ApprovalFile.GetFilesByApprovalIDsDB(ctx, approvalIDs); err == nil { + for _, f := range files { + if f.ApprovalID != nil { + filesMap[*f.ApprovalID] = append(filesMap[*f.ApprovalID], f) + } + } + } + + var stepsMap map[uint64][]*typescore.ApprovalStep + if loadSteps { + stepsMap = make(map[uint64][]*typescore.ApprovalStep) + steps, err := s.ipc.Database.ApprovalStep.GetApprovalStepsByApprovalIDsDB(ctx, approvalIDs) + if err == nil { + approverIDsSet := make(map[uint64]struct{}) + for _, st := range steps { + if st.ApprovalID != nil { + stepsMap[*st.ApprovalID] = append(stepsMap[*st.ApprovalID], st) + } + if st.ApproverID != nil { + approverIDsSet[*st.ApproverID] = struct{}{} + } + } + + approverIDs := make([]uint64, 0, len(approverIDsSet)) + for id := range approverIDsSet { + approverIDs = append(approverIDs, id) + } + approversMap := make(map[uint64]*typescore.User) + if approvers, err := s.ipc.Database.User.GetUsersByIDsDB(ctx, approverIDs); err == nil { + for _, u := range approvers { + if u.ID != nil { + approversMap[*u.ID] = u + } + } + } + for _, stepsForApproval := range stepsMap { + for _, st := range stepsForApproval { + if st.ApproverID != nil { + if approver, ok := approversMap[*st.ApproverID]; ok { + st.Approver = approver + } + } + } + } + } + } + + for _, a := range approvals { + if a.InitiatorID != nil { + if u, ok := usersMap[*a.InitiatorID]; ok { + a.Initiator = u + } + } + if a.RevokedByID != nil { + if u, ok := usersMap[*a.RevokedByID]; ok { + a.RevokedBy = u + } + } + if a.TopicID != nil { + if t, ok := topicsMap[*a.TopicID]; ok { + a.Topic = t + } + } + if a.DepartmentID != nil { + if d, ok := departmentsMap[*a.DepartmentID]; ok { + a.Department = d + } + } + if a.ID != nil { + a.Files = filesMap[*a.ID] + if loadSteps { + a.Steps = stepsMap[*a.ID] + } + } + } +} + +-----END handlers/approvals/handlers.go----- + +File: handlers/approvals/reports.go +Lines: 73 +-----BEGIN handlers/approvals/reports.go----- +package approvalshandler + +import ( + "bitrix_balancer_api/core/reportcore" + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/rest_admin_service/handlers" + "fmt" + "net/http" + "time" +) + +// DownloadApprovalsReportHandler Скачивание отчёта по заявкам в формате XLSX +// @Summary Скачивание отчёта по заявкам +// @Description Формирует и возвращает XLSX-файл отчёта по заявкам за указанный период +// @Tags approvals +// @Accept json +// @Produce application/vnd.openxmlformats-officedocument.spreadsheetml.sheet +// @Param date_from query string false "Начальная дата (YYYY-MM-DD)" +// @Param date_to query string false "Конечная дата (YYYY-MM-DD)" +// @Param all_access query boolean false "Полный доступ (игнорировать фильтрацию по пользователю)" +// @Success 200 {file} binary "XLSX файл" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/approvals/report/download [get] +func (s *ApprovalsReg) DownloadApprovalsReportHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + filter := typescore.ReportFilter{} + + // Парсим даты + if dateFromStr := queryParams.Get("date_from"); dateFromStr != "" { + dateFrom, err := time.Parse("2006-01-02", dateFromStr) + if err != nil { + return nil, fmt.Errorf("invalid date_from format, use YYYY-MM-DD") + } + filter.DateFrom = &dateFrom + } + + if dateToStr := queryParams.Get("date_to"); dateToStr != "" { + dateTo, err := time.Parse("2006-01-02", dateToStr) + if err != nil { + return nil, fmt.Errorf("invalid date_to format, use YYYY-MM-DD") + } + filter.DateTo = &dateTo + } + + // В админке всегда all_access = true (админ видит все заявки) + filter.AllAccess = true + + ctx := r.Context() + + // Получаем заявки для отчёта + approvals, err := s.ipc.Database.Approval.GetApprovalsForReportDB(ctx, filter) + if err != nil { + return nil, fmt.Errorf("failed to get approvals for report: %w", err) + } + + if len(approvals) == 0 { + return nil, fmt.Errorf("no approvals found for the specified period") + } + + excelBytes, err := reportcore.BuildExcelApprovalsReport(ctx, s.ipc.Database, approvals) + if err != nil { + return nil, fmt.Errorf("failed to build excel report: %w", err) + } + + fileName := fmt.Sprintf("Согласования_%s.xlsx", time.Now().Format("02.01.2006_15-04")) + + return &handlers.ExcelFileResponse{ + Data: excelBytes, + FileName: fileName, + }, nil +} + +-----END handlers/approvals/reports.go----- + +File: handlers/approvals/routes.go +Lines: 48 +-----BEGIN handlers/approvals/routes.go----- +package approvalshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type ApprovalsReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterApprovalRoutes регистрирует маршруты для группы approvals +func RegisterApprovalRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &ApprovalsReg{ + ipc: ipc, + } + + r.Route("/api/approvals", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetApprovalsListHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateApprovalHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteApprovalHandler) + + // Отчёты + handlers.RegisterRoute(r, http.MethodGet, "/report", s.GetApprovalsForReportHandler) + handlers.RegisterRoute(r, http.MethodGet, "/report/download", s.DownloadApprovalsReportHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetApprovalByIDHandler, + })) + r.Get("/{approval_id}/files/{file_id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetApprovalFileHandler, + })) + r.Get("/{approval_id}/files/{file_id}/download", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.DownloadApprovalFileHandler, + })) + }) + + return nil +} + +-----END handlers/approvals/routes.go----- + +File: handlers/auth/handlers.go +Lines: 204 +-----BEGIN handlers/auth/handlers.go----- +package authhandler + +import ( + "bitrix_balancer_api/core/securecore" + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/core/variables" + "bitrix_balancer_api/rest_admin_service/handlers" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/redis/go-redis/v9" + "io" + "net/http" + "time" + + "github.com/sirupsen/logrus" +) + +// GetServerTimeHandler возвращает текущее серверное время для синхронизации с клиентом +// @Summary Получить серверное время +// @Description Публичный endpoint для синхронизации часов клиента с сервером +// @Tags public +// @Produce json +// @Success 200 {object} map[string]interface{} +// @Router /api/time [get] +func (s *AuthReg) GetServerTimeHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + now := time.Now().UTC() + return map[string]interface{}{ + "timestamp": now.Unix(), + "iso": now.Format(time.RFC3339), + }, nil +} + +// TokenAuthHandler +// @Summary Авторизация при помощи JWT-токена +// @Description Авторизация при помощи JWT-токена +// @Tags auth +// @Accept json +// @Produce json +// @Success 200 {object} typescore.AuthHandlerResponse +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/auth/token [post] +func (s *AuthReg) TokenAuthHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + defer r.Body.Close() + + userID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, err + } + userObjAuthBody := &typescore.Admin{ + ID: &userID, + } + + usersList, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{Filtering: userObjAuthBody}) + if err != nil { + return nil, err + } + + if len(usersList) == 0 { + return nil, errors.New("no users found") + } + + if usersList[0].IsBlocked != nil && *usersList[0].IsBlocked { + return nil, errors.New("user is blocked") + } + + tokens, err := securecore.GenerateTokenJWT("", *usersList[0].ID, r.RemoteAddr, s.ipc.Config.Secrets.AuthJWT.UserSecret, s.ipc.Config.Secrets.AuthJWT.JwtUserSessionLengthHours) + if err != nil { + return nil, err + } + + return &typescore.AuthHandlerResponse{Token: &tokens}, nil +} + +// LoginByPasswordHandler авторизация с помощью связки логин-пароль +// @Summary авторизация с помощью связки логин-пароль +// @Description авторизация с помощью связки логин-пароль +// @Tags auth +// @Accept json +// @Produce json +// @Param request body typescore.AuthReqAccount true "Запрос" +// @Success 200 {object} typescore.AuthHandlerResponse +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/auth/login [post] +func (s *AuthReg) LoginByPasswordHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + ctx := r.Context() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 error LoginByPassword: ReadAll: ", err) + return nil, err + } + + if len(body) == 0 { + return nil, errors.New("body is empty") + } + + deviceID := r.Header.Get("x-device-id") + if deviceID == "" { + return nil, errors.New("device id is empty") + } + + var req typescore.AuthReqAccount + if err := json.Unmarshal(body, &req); err != nil { + return nil, err + } + + tokens, err := s.loginAcc(ctx, req.Login, req.Password, utilscore.GetClientIP(r), deviceID) + if err != nil { + return nil, err + } + if tokens == nil { + return nil, errors.New("token is nil") + } + + return &typescore.AuthHandlerResponse{Token: tokens}, nil +} + +func (s *AuthReg) loginAcc(ctx context.Context, login, password *string, ip, deviceID string) (*string, error) { + usersList, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{Filtering: &typescore.Admin{Login: login}}) + if err != nil { + return nil, err + } + + if usersList == nil || len(usersList) == 0 { + return nil, errors.New("no users found") + } + + loggedUser := usersList[0] + if password != nil && *password != "" { + validPass := securecore.CheckPasswordHash(password, loggedUser.PasswordHash) + if !validPass { + return nil, errors.New("invalid login or password") + } + } + + if loggedUser.IsBlocked != nil && *loggedUser.IsBlocked { + return nil, errors.New("user is blocked") + } + + lastLogin, err := time.Parse("2006-01-02 15:04:05", time.Now().UTC().Format("2006-01-02 15:04:05")) + if err != nil { + return nil, err + } + + keyPath := fmt.Sprintf("%s:admin:%d", variables.RedisPathUserAuthSessions, *loggedUser.ID) + sessionJSON, err := s.ipc.RedisClient.Get(ctx, keyPath) + if err != nil && !errors.Is(err, redis.Nil) { + return nil, err + } + + var session typescore.UsersSessions + + if sessionJSON != "" { + if err := json.Unmarshal([]byte(sessionJSON), &session); err != nil { + return nil, err + } + } else { + session = typescore.UsersSessions{ + UserID: loggedUser.ID, + LastIP: ip, + } + } + + foundDevice := securecore.FindDeviceID(session.AuthorizedDevices, deviceID) + if !foundDevice { + now := time.Now().UTC() + session.AuthorizedDevices = append(session.AuthorizedDevices, typescore.DeviceList{ + DeviceID: deviceID, + CreatedAt: &now, + }) + + sessionJSONBytes, err := json.Marshal(session) + if err != nil { + return nil, fmt.Errorf("failed to marshal session: %w", err) + } + + err = s.ipc.RedisClient.Set(ctx, keyPath, string(sessionJSONBytes), 0) + if err != nil { + return nil, fmt.Errorf("failed to save session to Redis: %w", err) + } + } + + loggedUser.LastLogin = &lastLogin + loggedUser.LastIPLogin = &ip + + upUser, _, err := s.ipc.Database.Admin.UpdateAdminDB(nil, loggedUser, true) + if err != nil { + return nil, err + } + + tokens, err := securecore.GenerateTokenJWT("", *upUser.ID, ip, s.ipc.Config.Secrets.AuthJWT.AdminSecret, s.ipc.Config.Secrets.AuthJWT.JwtAdminSessionLengthHours) + if err != nil { + return nil, err + } + + return &tokens, nil +} + +-----END handlers/auth/handlers.go----- + +File: handlers/auth/routes.go +Lines: 40 +-----BEGIN handlers/auth/routes.go----- +package authhandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "github.com/go-chi/chi/v5" + "net/http" +) + +const ( + oauthURLogin = "/auth/login" // вход по паролю +) + +type AuthReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterAuthRoutes регистрирует маршруты для группы auth +func RegisterAuthRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &AuthReg{ + ipc: ipc, + } + + handlers.RegisterRoute(r, http.MethodGet, "/api/time", s.GetServerTimeHandler) + + r.Route("/api", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + handlers.RegisterRoute(r, http.MethodPost, oauthURLogin, s.LoginByPasswordHandler) + }) + + r.Route("/api/auth/token", func(r chi.Router) { + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, s.ipc.RedisClient)) + handlers.RegisterRoute(r, http.MethodPost, "/", s.TokenAuthHandler) + }) + + return nil +} + +-----END handlers/auth/routes.go----- + +File: handlers/dashboard/handlers.go +Lines: 908 +-----BEGIN handlers/dashboard/handlers.go----- +package dashboardhandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "context" + "encoding/json" + "fmt" + "net/http" + "regexp" + "strconv" + "strings" + "time" +) + +// GetDashboardStatsHandler — возвращает все данные для дашборда одним запросом +func (s *DashboardReg) GetDashboardStatsHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + // === 1. KPI: считаем сущности === + totalUsers := s.countUsers(ctx, &typescore.User{}) + activeUsers := s.countUsers(ctx, &typescore.User{IsBlocked: boolPtr(false), IsFired: boolPtr(false)}) + blockedUsers := s.countUsers(ctx, &typescore.User{IsBlocked: boolPtr(true)}) + + totalApprovals := s.countApprovals(ctx, &typescore.Approval{}) + pendingApprovals := s.countApprovalsByStatus(ctx, "pending") + revisionApprovals := s.countApprovalsByStatus(ctx, "revision") + approvedToday := s.countApprovalsByStatusAndDate(ctx, "approved", time.Now()) + + totalTopics := s.countTopics(ctx, &typescore.ApprovalTopic{}) + activeTopics := s.countTopics(ctx, &typescore.ApprovalTopic{IsActive: boolPtr(true)}) + totalCategories := s.countCategories(ctx) + totalDepartments := s.countDepartments(ctx) + totalRoles := s.countRoles(ctx) + totalExecutors := s.countExecutors(ctx) + + // === 2. Распределение заявок по статусам === + statuses := []string{"draft", "pending", "approved", "rejected", "revoked", "revision"} + statusData := make([]map[string]interface{}, 0, len(statuses)) + for _, status := range statuses { + count := s.countApprovalsByStatus(ctx, status) + statusData = append(statusData, map[string]interface{}{ + "status": status, + "count": count, + }) + } + + // === 3. Динамика за последние 7 дней === + dailyData := make([]map[string]interface{}, 0, 7) + now := time.Now() + for i := 6; i >= 0; i-- { + date := now.AddDate(0, 0, -i) + created := s.countApprovalsCreatedOn(ctx, date) + approved := s.countApprovalsApprovedOn(ctx, date) + + dailyData = append(dailyData, map[string]interface{}{ + "date": date.Format("2006-01-02"), + "created": created, + "approved": approved, + }) + } + + // === 4. Разбивка по категориям (вместо топ-5 тем) === + categoryBreakdown := s.getCategoryBreakdown(ctx) + + // === 5. Узкие места: согласующие с просроченными заявками (вместо топ-5 по активности) === + bottleneckApprovers := s.getBottleneckApprovers(ctx, 5, 7) + + // === 6. Старые pending заявки (>7 дней) === + oldPendingCount := s.countOldPendingApprovals(ctx, 7) + + // === 7. 🆕 Задачи: распределение по статусам + динамика за 7 дней === + taskStatusData := s.getTaskStatusData(ctx) + taskDailyData := s.getTaskDailyData(ctx) + + // === 8. 🆕 Кто отсутствует сегодня (отгул/отпуск/больничный) === + absentToday := s.getAbsentToday(ctx) + + // === 9. 🆕 Проблемы конфигурации: темы без назначенного порядка + // согласования для конкретного пользователя + пользователи вообще + // без иерархии в своём отделе === + topicGaps, usersWithoutHierarchy := s.getInitiatorConfigWarnings(ctx) + + return map[string]interface{}{ + "users": map[string]int{ + "total": totalUsers, + "active": activeUsers, + "blocked": blockedUsers, + }, + "approvals": map[string]int{ + "total": totalApprovals, + "pending": pendingApprovals, + "revision": revisionApprovals, + "today": approvedToday, + }, + "topics": map[string]int{ + "total": totalTopics, + "active": activeTopics, + }, + "categories": totalCategories, + "departments": totalDepartments, + "roles": totalRoles, + "executors": totalExecutors, + "statusData": statusData, + "dailyData": dailyData, + "categoryBreakdown": categoryBreakdown, + "bottleneckApprovers": bottleneckApprovers, + "oldPendingCount": oldPendingCount, + "oldPendingDays": 7, + "taskStatusData": taskStatusData, + "taskDailyData": taskDailyData, + "absentToday": absentToday, + "topicGaps": topicGaps, + "usersWithoutHierarchy": usersWithoutHierarchy, + }, nil +} + +// ============================================================ +// Вспомогательные методы для подсчёта +// ============================================================ + +func (s *DashboardReg) countUsers(ctx context.Context, filter *typescore.User) int { + opts := typescore.ListDbOptions{ + Filtering: filter, + Limit: utilscore.PointerToUint64(10000), // считаем через len + } + list, _, err := s.ipc.Database.User.GetUsersListDB(ctx, opts) + if err != nil { + return 0 + } + return len(list) +} + +func (s *DashboardReg) countApprovals(ctx context.Context, filter *typescore.Approval) int { + opts := typescore.ListDbOptions{ + Filtering: filter, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.Approval.GetApprovalsListDB(ctx, opts) + if err != nil { + return 0 + } + return len(list) +} + +func (s *DashboardReg) countApprovalsByStatus(ctx context.Context, status string) int { + return s.countApprovals(ctx, &typescore.Approval{Status: &status}) +} + +func (s *DashboardReg) countApprovalsByStatusAndDate(ctx context.Context, status string, date time.Time) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.Approval{Status: &status}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.Approval.GetApprovalsListDB(ctx, opts) + if err != nil { + return 0 + } + + count := 0 + today := date.Format("2006-01-02") + for _, a := range list { + if a.CreatedAt != nil && a.CreatedAt.Format("2006-01-02") == today { + count++ + } + } + return count +} + +func (s *DashboardReg) countApprovalsCreatedOn(ctx context.Context, date time.Time) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.Approval{}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.Approval.GetApprovalsListDB(ctx, opts) + if err != nil { + return 0 + } + + count := 0 + target := date.Format("2006-01-02") + for _, a := range list { + if a.CreatedAt != nil && a.CreatedAt.Format("2006-01-02") == target { + count++ + } + } + return count +} + +func (s *DashboardReg) countApprovalsApprovedOn(ctx context.Context, date time.Time) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalStep{Status: strPtr("approved")}, + Limit: utilscore.PointerToUint64(10000), + } + steps, _, err := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(ctx, opts) + if err != nil { + return 0 + } + + uniqueApprovals := make(map[uint64]bool) + target := date.Format("2006-01-02") + for _, step := range steps { + if step.ActedAt != nil && step.ActedAt.Format("2006-01-02") == target && step.ApprovalID != nil { + uniqueApprovals[*step.ApprovalID] = true + } + } + return len(uniqueApprovals) +} + +func (s *DashboardReg) countTopics(ctx context.Context, filter *typescore.ApprovalTopic) int { + opts := typescore.ListDbOptions{ + Filtering: filter, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, opts) + if err != nil { + return 0 + } + return len(list) +} + +func (s *DashboardReg) countCategories(ctx context.Context) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicCategory{}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, opts) + if err != nil { + return 0 + } + return len(list) +} + +func (s *DashboardReg) countDepartments(ctx context.Context) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.Department{}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.Department.GetDepartmentsListDB(ctx, opts) + if err != nil { + return 0 + } + return len(list) +} + +func (s *DashboardReg) countRoles(ctx context.Context) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.Role{}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.Role.GetRolesListDB(ctx, opts) + if err != nil { + return 0 + } + return len(list) +} + +func (s *DashboardReg) countExecutors(ctx context.Context) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicExecutor{}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.ApprovalTopicExecutor.GetApprovalTopicExecutorListDB(ctx, opts) + if err != nil { + return 0 + } + return len(list) +} + +func (s *DashboardReg) countOldPendingApprovals(ctx context.Context, days int) int { + opts := typescore.ListDbOptions{ + Filtering: &typescore.Approval{Status: strPtr("pending")}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.Approval.GetApprovalsListDB(ctx, opts) + if err != nil { + return 0 + } + + cutoff := time.Now().AddDate(0, 0, -days) + count := 0 + for _, a := range list { + if a.CreatedAt != nil && a.CreatedAt.Before(cutoff) { + count++ + } + } + return count +} + +// ============================================================ +// Разбивка заявок по категориям (заменяет прежний "топ-5 тем"). +// ============================================================ + +func (s *DashboardReg) getCategoryBreakdown(ctx context.Context) []map[string]interface{} { + topicOpts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopic{}, + Limit: utilscore.PointerToUint64(10000), + } + topics, _, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, topicOpts) + if err != nil { + return []map[string]interface{}{} + } + topicToCategory := make(map[uint64]uint64, len(topics)) + for _, t := range topics { + if t.ID != nil && t.CategoryID != nil { + topicToCategory[*t.ID] = *t.CategoryID + } + } + + categoryOpts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicCategory{}, + Limit: utilscore.PointerToUint64(10000), + } + categories, _, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, categoryOpts) + if err != nil { + return []map[string]interface{}{} + } + categoryNames := make(map[uint64]string, len(categories)) + for _, c := range categories { + if c.ID != nil && c.Name != nil { + categoryNames[*c.ID] = *c.Name + } + } + + approvalOpts := typescore.ListDbOptions{ + Filtering: &typescore.Approval{}, + Limit: utilscore.PointerToUint64(10000), + } + approvals, _, err := s.ipc.Database.Approval.GetApprovalsListDB(ctx, approvalOpts) + if err != nil { + return []map[string]interface{}{} + } + + type catStat struct { + total int + pending int + } + byCategory := make(map[uint64]*catStat) + for _, a := range approvals { + if a.TopicID == nil { + continue + } + categoryID, ok := topicToCategory[*a.TopicID] + if !ok { + continue + } + if byCategory[categoryID] == nil { + byCategory[categoryID] = &catStat{} + } + byCategory[categoryID].total++ + if a.Status != nil && *a.Status == "pending" { + byCategory[categoryID].pending++ + } + } + + type entry struct { + id uint64 + total int + pending int + } + entries := make([]entry, 0, len(byCategory)) + for id, st := range byCategory { + entries = append(entries, entry{id: id, total: st.total, pending: st.pending}) + } + for i := 0; i < len(entries); i++ { + for j := i + 1; j < len(entries); j++ { + if entries[j].total > entries[i].total { + entries[i], entries[j] = entries[j], entries[i] + } + } + } + + result := make([]map[string]interface{}, 0, len(entries)) + for _, e := range entries { + name := categoryNames[e.id] + if name == "" { + continue + } + result = append(result, map[string]interface{}{ + "id": e.id, + "name": name, + "total_count": e.total, + "pending_count": e.pending, + }) + } + + return result +} + +// ============================================================ +// Узкие места: согласующие с просроченными (>days дней с подачи) заявками. +// ============================================================ + +func (s *DashboardReg) getBottleneckApprovers(ctx context.Context, limit int, days int) []map[string]interface{} { + stepOpts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalStep{Status: strPtr("pending")}, + Limit: utilscore.PointerToUint64(10000), + } + steps, _, err := s.ipc.Database.ApprovalStep.GetApprovalStepsListDB(ctx, stepOpts) + if err != nil { + return []map[string]interface{}{} + } + + cutoff := time.Now().AddDate(0, 0, -days) + + type approverStat struct { + pendingTotal int + overdue int + } + stats := make(map[uint64]*approverStat) + + for _, step := range steps { + if step.ApproverID == nil || step.ApprovalID == nil { + continue + } + approval, err := s.ipc.Database.Approval.GetApprovalByIDDB(ctx, *step.ApprovalID) + if err != nil || approval == nil || approval.CreatedAt == nil { + continue + } + + id := *step.ApproverID + if stats[id] == nil { + stats[id] = &approverStat{} + } + stats[id].pendingTotal++ + if approval.CreatedAt.Before(cutoff) { + stats[id].overdue++ + } + } + + type entry struct { + id uint64 + pendingTotal int + overdue int + } + entries := make([]entry, 0, len(stats)) + for id, st := range stats { + if st.overdue == 0 { + continue + } + entries = append(entries, entry{id: id, pendingTotal: st.pendingTotal, overdue: st.overdue}) + } + for i := 0; i < len(entries); i++ { + for j := i + 1; j < len(entries); j++ { + if entries[j].overdue > entries[i].overdue { + entries[i], entries[j] = entries[j], entries[i] + } + } + } + + result := make([]map[string]interface{}, 0, limit) + for i := 0; i < len(entries) && i < limit; i++ { + e := entries[i] + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, e.id) + if err != nil || user == nil { + continue + } + + fullName := "" + if user.FullName != nil { + fullName = *user.FullName + } + + deptName := "" + if user.DepartmentID != nil { + dept, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *user.DepartmentID) + if err == nil && dept != nil && dept.Name != nil { + deptName = *dept.Name + } + } + + result = append(result, map[string]interface{}{ + "user_id": e.id, + "full_name": fullName, + "department_name": deptName, + "pending_total": e.pendingTotal, + "overdue_count": e.overdue, + }) + } + + return result +} + +// ============================================================ +// 🆕 Задачи: распределение по статусам + динамика за 7 дней. +// Полностью аналогично разделам про заявки — те же графики, другая +// таблица (ApprovalTask вместо Approval). +// ============================================================ + +func (s *DashboardReg) getTaskStatusData(ctx context.Context) []map[string]interface{} { + statuses := []string{"pending", "waiting", "completed", "cancelled"} + result := make([]map[string]interface{}, 0, len(statuses)) + for _, status := range statuses { + st := status + opts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTask{Status: &st}, + Limit: utilscore.PointerToUint64(10000), + } + list, _, err := s.ipc.Database.ApprovalTasks.GetApprovalTasksListDB(ctx, opts) + count := 0 + if err == nil { + count = len(list) + } + result = append(result, map[string]interface{}{ + "status": status, + "count": count, + }) + } + return result +} + +func (s *DashboardReg) getTaskDailyData(ctx context.Context) []map[string]interface{} { + opts := typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTask{}, + Limit: utilscore.PointerToUint64(10000), + } + tasks, _, err := s.ipc.Database.ApprovalTasks.GetApprovalTasksListDB(ctx, opts) + if err != nil { + tasks = nil + } + + result := make([]map[string]interface{}, 0, 7) + now := time.Now() + for i := 6; i >= 0; i-- { + date := now.AddDate(0, 0, -i) + target := date.Format("2006-01-02") + + created := 0 + completed := 0 + for _, t := range tasks { + if t.CreatedAt != nil && t.CreatedAt.Format("2006-01-02") == target { + created++ + } + if t.CompletedAt != nil && t.CompletedAt.Format("2006-01-02") == target { + completed++ + } + } + + result = append(result, map[string]interface{}{ + "date": target, + "created": created, + "completed": completed, + }) + } + return result +} + +// ============================================================ +// 🆕 Кто отсутствует сегодня (отгул/отпуск/больничный). +// +// 🩹 Логика разбора дат намеренно продублирована из +// scheduler/daily_reminder.go (getAbsentEmployeesToday) — тот же самый +// терпимый к опечаткам подход через regexp, т.к. у заявок на отсутствие +// нет отдельного структурированного поля с датами. rest_admin_service +// использует свой ipc-тип, отличный от telegram_service, поэтому +// переиспользовать функцию напрямую нельзя — общий пакет пока не заводили. +// +// Упрощение по сравнению с ботом: здесь НЕ подмешивается контакт-делегат +// (ApprovalDelegation) — просто список отсутствующих с описанием. +// ============================================================ + +type dashboardAbsenceMetadata struct { + Extra struct { + TimeType string `json:"time_type"` + AbsenceType string `json:"absence_type"` + } `json:"extra"` +} + +var dashboardAbsenceDateRe = regexp.MustCompile(`(\d{1,2})[.,](\d{1,2})\.(\d{4})`) +var dashboardAbsenceTimeRe = regexp.MustCompile(`(\d{1,2}):(\d{2}).*?(\d{1,2}):(\d{2})`) + +func (s *DashboardReg) getAbsentToday(ctx context.Context) []map[string]interface{} { + loc, err := time.LoadLocation("Europe/Moscow") + if err != nil { + loc = time.FixedZone("MSK", 3*3600) + } + today := time.Now().In(loc) + todayY, todayM, todayD := today.Date() + + approvals, _, err := s.ipc.Database.Approval.GetApprovalsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Approval{Status: strPtr("approved")}, + Limit: utilscore.PointerToUint64(10000), + }) + if err != nil { + return []map[string]interface{}{} + } + + seenUsers := make(map[uint64]bool) + result := []map[string]interface{}{} + + for _, a := range approvals { + if a.Metadata == nil || *a.Metadata == "" || a.Content == nil || a.InitiatorID == nil { + continue + } + if seenUsers[*a.InitiatorID] { + continue + } + + var meta dashboardAbsenceMetadata + if err := json.Unmarshal([]byte(*a.Metadata), &meta); err != nil || meta.Extra.AbsenceType == "" { + continue + } + + dates := parseDashboardAbsenceDates(*a.Content) + if len(dates) == 0 || !dashboardAbsenceCoversDate(dates, *a.Content, todayY, todayM, todayD) { + continue + } + + name := "" + if user, uErr := s.ipc.Database.User.GetUserByIDDB(ctx, *a.InitiatorID); uErr == nil && user != nil && user.FullName != nil { + name = *user.FullName + } + + var description string + switch meta.Extra.AbsenceType { + case "timeoff": + if meta.Extra.TimeType == "partial" { + if mm := dashboardAbsenceTimeRe.FindStringSubmatch(*a.Content); mm != nil { + description = "отгул с " + mm[1] + ":" + mm[2] + " до " + mm[3] + ":" + mm[4] + } else { + description = "отгул весь день" + } + } else { + description = "отгул весь день" + } + case "vacation": + description = "отпуск до " + maxDashboardAbsenceDate(dates).Format("02.01.2006") + case "sickleave": + description = "больничный до " + maxDashboardAbsenceDate(dates).Format("02.01.2006") + default: + description = "отсутствует" + } + + seenUsers[*a.InitiatorID] = true + result = append(result, map[string]interface{}{ + "name": name, + "description": description, + }) + } + + return result +} + +func parseDashboardAbsenceDates(content string) []time.Time { + matches := dashboardAbsenceDateRe.FindAllStringSubmatch(content, -1) + var dates []time.Time + for _, m := range matches { + day, errD := strconv.Atoi(m[1]) + month, errM := strconv.Atoi(m[2]) + year, errY := strconv.Atoi(m[3]) + if errD != nil || errM != nil || errY != nil { + continue + } + if month < 1 || month > 12 || day < 1 || day > 31 { + continue + } + dates = append(dates, time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)) + } + return dates +} + +func dashboardAbsenceCoversDate(dates []time.Time, content string, y int, m time.Month, d int) bool { + target := time.Date(y, m, d, 0, 0, 0, 0, time.UTC) + if len(dates) == 2 && strings.Contains(content, "-") { + start, end := dates[0], dates[1] + if end.Before(start) { + start, end = end, start + } + return !target.Before(start) && !target.After(end) + } + for _, dt := range dates { + if dt.Equal(target) { + return true + } + } + return false +} + +func maxDashboardAbsenceDate(dates []time.Time) time.Time { + max := dates[0] + for _, d := range dates[1:] { + if d.After(max) { + max = d + } + } + return max +} + +// ============================================================ +// 🆕 Проблемы конфигурации инициаторов. +// +// Воспроизводит ТУ ЖЕ логику резолва согласующих, что и сам бот при +// реальной отправке заявки (submitApproval → UserHierarchy по +// SubordinateID+DepartmentID, с приоритетом TopicID → TopicCategoryID → +// глобальное правило) — но заранее, для ВСЕХ пользователей и ВСЕХ тем, +// на которые у них есть право "create", чтобы найти дыры ДО того, как +// сотрудник наткнётся на них в боте ("⚠️ Для вас в данной теме не +// настроены согласующие"). +// +// Возвращает два среза: +// 1. topicGaps — точечные пробелы: у пользователя ЕСТЬ право создавать +// заявку по теме, но НИ ОДНО правило иерархии её не покрывает. +// 2. usersWithoutHierarchy — более базовый случай: у пользователя нет +// вообще ни одной строки UserHierarchy для его отдела (полностью +// не настроен, даже глобального правила нет). +// +// ⚠️ Предположения, которые стоит проверить при первом запуске: +// - Permission.GetUserPermissionsDB(ctx, userID, "create") доступен +// из rest_admin_service так же, как используется ботом +// (telegram_service/handlers/approval, getAllowedTopicCodes) — +// сама структура Permission (поля TopicID/TopicCategoryID) взята +// оттуда же, полностью структуру Permission я не видел. +// - Пользователи без DepartmentID пропускаются целиком (это отдельная, +// более базовая проблема — некому резолвить иерархию в принципе, +// не про конкретные темы). +// ============================================================ + +func (s *DashboardReg) getInitiatorConfigWarnings(ctx context.Context) ([]map[string]interface{}, []map[string]interface{}) { + users, _, err := s.ipc.Database.User.GetUsersListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.User{IsBlocked: boolPtr(false), IsFired: boolPtr(false)}, + Limit: utilscore.PointerToUint64(10000), + }) + if err != nil { + return []map[string]interface{}{}, []map[string]interface{}{} + } + + topics, _, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopic{IsActive: boolPtr(true)}, + Limit: utilscore.PointerToUint64(10000), + }) + if err != nil { + return []map[string]interface{}{}, []map[string]interface{}{} + } + + categories, _, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, typescore.ListDbOptions{ + Limit: utilscore.PointerToUint64(10000), + }) + categoryNames := make(map[uint64]string, len(categories)) + if err == nil { + for _, c := range categories { + if c.ID != nil && c.Name != nil { + categoryNames[*c.ID] = *c.Name + } + } + } + + departments, _, err := s.ipc.Database.Department.GetDepartmentsListDB(ctx, typescore.ListDbOptions{ + Limit: utilscore.PointerToUint64(10000), + }) + departmentNames := make(map[uint64]string, len(departments)) + if err == nil { + for _, d := range departments { + if d.ID != nil && d.Name != nil { + departmentNames[*d.ID] = *d.Name + } + } + } + + topicByID := make(map[uint64]*typescore.ApprovalTopic, len(topics)) + topicsByCategory := make(map[uint64][]*typescore.ApprovalTopic) + for _, t := range topics { + if t.ID == nil { + continue + } + topicByID[*t.ID] = t + if t.CategoryID != nil { + topicsByCategory[*t.CategoryID] = append(topicsByCategory[*t.CategoryID], t) + } + } + + hierarchies, _, err := s.ipc.Database.UserHierarchy.GetUserHierarchyListDB(ctx, typescore.ListDbOptions{ + Limit: utilscore.PointerToUint64(10000), + }) + if err != nil { + return []map[string]interface{}{}, []map[string]interface{}{} + } + + type coverage struct { + topics map[uint64]bool + categories map[uint64]bool + global bool + } + coverageKey := func(userID, deptID uint64) string { + return fmt.Sprintf("%d:%d", userID, deptID) + } + coverageByUserDept := make(map[string]*coverage) + for _, h := range hierarchies { + if h.SubordinateID == nil || h.DepartmentID == nil { + continue + } + k := coverageKey(*h.SubordinateID, *h.DepartmentID) + cov, ok := coverageByUserDept[k] + if !ok { + cov = &coverage{topics: map[uint64]bool{}, categories: map[uint64]bool{}} + coverageByUserDept[k] = cov + } + switch { + case h.TopicID != nil: + cov.topics[*h.TopicID] = true + case h.TopicCategoryID != nil: + cov.categories[*h.TopicCategoryID] = true + default: + cov.global = true + } + } + + isCovered := func(userID, deptID, topicID uint64, categoryID *uint64) bool { + cov, ok := coverageByUserDept[coverageKey(userID, deptID)] + if !ok { + return false + } + if cov.global { + return true + } + if cov.topics[topicID] { + return true + } + if categoryID != nil && cov.categories[*categoryID] { + return true + } + return false + } + + var topicGaps []map[string]interface{} + var usersWithoutHierarchy []map[string]interface{} + + for _, user := range users { + if user.ID == nil || user.DepartmentID == nil { + continue + } + + perms, err := s.ipc.Database.Permission.GetUserPermissionsDB(ctx, *user.ID, "create") + if err != nil || len(perms) == 0 { + continue // нет права создавать ничего — не наша забота здесь + } + + userName := "" + if user.FullName != nil { + userName = *user.FullName + } + deptName := departmentNames[*user.DepartmentID] + + // --- Проверка "вообще нет иерархии для этого отдела" --- + if _, hasAny := coverageByUserDept[coverageKey(*user.ID, *user.DepartmentID)]; !hasAny { + usersWithoutHierarchy = append(usersWithoutHierarchy, map[string]interface{}{ + "user_id": *user.ID, + "full_name": userName, + "department_name": deptName, + }) + continue // если вообще ничего нет — детальный разбор по темам избыточен + } + + // --- Точечные пробелы по темам --- + allowedTopicIDs := make(map[uint64]bool) + for _, p := range perms { + if p.TopicID != nil { + allowedTopicIDs[*p.TopicID] = true + } + if p.TopicCategoryID != nil { + for _, t := range topicsByCategory[*p.TopicCategoryID] { + if t.ID != nil { + allowedTopicIDs[*t.ID] = true + } + } + } + } + + for topicID := range allowedTopicIDs { + topic := topicByID[topicID] + if topic == nil { + continue + } + if isCovered(*user.ID, *user.DepartmentID, topicID, topic.CategoryID) { + continue + } + + topicName := "" + if topic.Name != nil { + topicName = *topic.Name + } + categoryName := "" + if topic.CategoryID != nil { + categoryName = categoryNames[*topic.CategoryID] + } + + topicGaps = append(topicGaps, map[string]interface{}{ + "user_id": *user.ID, + "full_name": userName, + "department_name": deptName, + "topic_id": topicID, + "topic_name": topicName, + "category_name": categoryName, + }) + } + } + + if topicGaps == nil { + topicGaps = []map[string]interface{}{} + } + if usersWithoutHierarchy == nil { + usersWithoutHierarchy = []map[string]interface{}{} + } + + return topicGaps, usersWithoutHierarchy +} + +func boolPtr(b bool) *bool { return &b } +func strPtr(s string) *string { return &s } + +-----END handlers/dashboard/handlers.go----- + +File: handlers/dashboard/routes.go +Lines: 33 +-----BEGIN handlers/dashboard/routes.go----- +package dashboardhandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type DashboardReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterDashboardRoutes регистрирует маршруты для дашборда +func RegisterDashboardRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &DashboardReg{ + ipc: ipc, + } + + r.Route("/api/dashboard", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + // 📊 Основная статистика (всё сразу одним запросом) + handlers.RegisterRoute(r, http.MethodGet, "/stats", s.GetDashboardStatsHandler) + }) + + return nil +} + +-----END handlers/dashboard/routes.go----- + +File: handlers/departments/handlers.go +Lines: 344 +-----BEGIN handlers/departments/handlers.go----- +package departmentshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" +) + +// GetDepartmentsListHandler Получение списка отделов +// @Summary Получение списка отделов +// @Description Получение списка отделов с пагинацией и фильтрацией +// @Tags departments +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param is_active query boolean false "Фильтр по активности" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/departments [get] +func (s *DepartmentsReg) GetDepartmentsListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + departmentParams := &typescore.Department{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, departmentParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: departmentParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + departmentsDbLst, total, errW := s.ipc.Database.Department.GetDepartmentsListDB(ctx, options) + if errW != nil { + return nil, errW + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: departmentsDbLst, + }, nil +} + +// GetDepartmentByIDHandler Получение отдела по ID +// @Summary Получение отдела по ID +// @Description Получение детальной информации об отделе по его ID +// @Tags departments +// @Accept json +// @Produce json +// @Param id path integer true "ID отдела" +// @Success 200 {object} typescore.Department "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Отдел не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/departments/{id} [get] +func (s *DepartmentsReg) GetDepartmentByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("department id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid department id") + } + + ctx := r.Context() + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, id) + if err != nil { + return nil, err + } + + if department == nil { + return nil, errors.New("department not found") + } + + return department, nil +} + +// CreateDepartmentHandler Создание отдела +// @Summary Создание отдела +// @Description Создание нового отдела +// @Tags departments +// @Accept json +// @Produce json +// @Param request body typescore.Department true "Данные отдела" +// @Success 200 {object} typescore.Department "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/departments [post] +func (s *DepartmentsReg) CreateDepartmentHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreateDepartmentHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Department + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.Name == nil || *req.Name == "" { + return nil, errors.New("department name is required") + } + if req.Code == nil || *req.Code == "" { + return nil, errors.New("department code is required") + } + + ctx := r.Context() + existingDepts, _, err := s.ipc.Database.Department.GetDepartmentsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Department{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingDepts) > 0 { + return nil, errors.New("department code already exists") + } + + if req.IsActive == nil { + isActive := true + req.IsActive = &isActive + } + + createdDept, _, err := s.ipc.Database.Department.CreateDepartmentDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(createdDept.Name), + "code": utilscore.DerefStr(createdDept.Code), + "is_active": utilscore.DerefBool(createdDept.IsActive), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "department", createdDept.ID, + fmt.Sprintf("Создан отдел «%s»", utilscore.DerefStr(createdDept.Name)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return createdDept, nil +} + +// UpdateDepartmentHandler Обновление отдела +// @Summary Обновление отдела +// @Description Обновление данных существующего отдела +// @Tags departments +// @Accept json +// @Produce json +// @Param request body typescore.Department true "Данные отдела" +// @Success 200 {object} typescore.Department "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Отдел не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/departments [put] +func (s *DepartmentsReg) UpdateDepartmentHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateDepartmentHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Department + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("department id is required") + } + + ctx := r.Context() + existingDept, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingDept == nil { + return nil, errors.New("department not found") + } + + if req.Code != nil && *req.Code != "" { + if existingDept.Code == nil || *existingDept.Code != *req.Code { + existingDepts, _, err := s.ipc.Database.Department.GetDepartmentsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Department{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingDepts) > 0 { + return nil, errors.New("department code already exists") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.Name != nil && !utilscore.StrEq(existingDept.Name, req.Name) { + changes = append(changes, fieldChange{"name", utilscore.DerefStr(existingDept.Name), *req.Name}) + summary = append(summary, fmt.Sprintf("название: «%s» → «%s»", utilscore.DerefStr(existingDept.Name), *req.Name)) + } + if req.Code != nil && !utilscore.StrEq(existingDept.Code, req.Code) { + changes = append(changes, fieldChange{"code", utilscore.DerefStr(existingDept.Code), *req.Code}) + summary = append(summary, fmt.Sprintf("код: «%s» → «%s»", utilscore.DerefStr(existingDept.Code), *req.Code)) + } + if req.IsActive != nil && !utilscore.BoolEq(existingDept.IsActive, req.IsActive) { + changes = append(changes, fieldChange{"is_active", utilscore.DerefBool(existingDept.IsActive), *req.IsActive}) + if *req.IsActive { + summary = append(summary, "активирован") + } else { + summary = append(summary, "деактивирован") + } + } + + updatedDept, _, err := s.ipc.Database.Department.UpdateDepartmentDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + description := fmt.Sprintf("Изменён отдел «%s»: %s", utilscore.DerefStr(existingDept.Name), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "department", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return updatedDept, nil +} + +// DeleteDepartmentHandler Удаление отдела +// @Summary Удаление отдела +// @Description Удаление отдела по ID +// @Tags departments +// @Accept json +// @Produce json +// @Param request body typescore.Department true "ID отдела для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Отдел не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/departments [delete] +func (s *DepartmentsReg) DeleteDepartmentHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteDepartmentHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Department + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("department id is required") + } + + ctx := r.Context() + existingDept, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingDept == nil { + return nil, errors.New("department not found") + } + + err = s.ipc.Database.Department.DeleteDepartmentDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(existingDept.Name), + "code": utilscore.DerefStr(existingDept.Code), + "is_active": utilscore.DerefBool(existingDept.IsActive), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "department", req.ID, + fmt.Sprintf("Удалён отдел «%s»", utilscore.DerefStr(existingDept.Name)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func (s *DepartmentsReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/departments/handlers.go----- + +File: handlers/departments/routes.go +Lines: 47 +-----BEGIN handlers/departments/routes.go----- +package departmentshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type DepartmentsReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterDepartmentRoutes регистрирует маршруты для группы departments +func RegisterDepartmentRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &DepartmentsReg{ + ipc: ipc, + } + + r.Route("/api/departments", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + // GET /api/departments - список отделов + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetDepartmentsListHandler) + + // POST /api/departments - создание отдела + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateDepartmentHandler) + + // PUT /api/departments - обновление отдела + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateDepartmentHandler) + + // DELETE /api/departments - удаление отдела + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteDepartmentHandler) + + // GET /api/departments/{id} - получение отдела по ID + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetDepartmentByIDHandler, + })) + }) + + return nil +} + +-----END handlers/departments/routes.go----- + +File: handlers/flow_nodes/handler.go +Lines: 837 +-----BEGIN handlers/flow_nodes/handler.go----- +package nodeshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + "strconv" + + "github.com/go-chi/chi/v5" +) + +func (s *FlowNodesReg) GetFlowNodesByCategoryIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + categoryIDStr := chi.URLParam(r, "category_id") + categoryID, err := strconv.ParseUint(categoryIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid category_id") + } + + ctx := r.Context() + + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, categoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("category not found") + } + + nodes, _, err := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{CategoryID: &categoryID}, + }) + if err != nil { + return nil, err + } + + tree := s.buildTreeFromNodes(nodes) + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(nodes)), + Data: tree, + }, nil +} + +func (s *FlowNodesReg) GetFlowNodeByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("node id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid node id") + } + + ctx := r.Context() + node, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, id) + if err != nil { + return nil, err + } + if node == nil { + return nil, errors.New("node not found") + } + + return node, nil +} + +func (s *FlowNodesReg) CreateFlowNodeHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req typescore.ApprovalFlowNode + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.CategoryID == nil { + return nil, errors.New("category_id is required") + } + if req.Key == nil || *req.Key == "" { + return nil, errors.New("key is required") + } + if req.Label == nil || *req.Label == "" { + return nil, errors.New("label is required") + } + + ctx := r.Context() + + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.CategoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("category not found") + } + + if req.ParentID != nil { + parent, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, *req.ParentID) + if err != nil { + return nil, err + } + if parent == nil { + return nil, errors.New("parent node not found") + } + if parent.CategoryID == nil || *parent.CategoryID != *req.CategoryID { + return nil, errors.New("parent node belongs to a different category") + } + } + + existing, _, err := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{ + CategoryID: req.CategoryID, + Key: req.Key, + }, + }) + if err != nil { + return nil, err + } + if len(existing) > 0 { + return nil, fmt.Errorf("node with key '%s' already exists in this category", *req.Key) + } + + if req.IsInput == nil { + v := false + req.IsInput = &v + } + if req.IsMultiSelect == nil { + v := false + req.IsMultiSelect = &v + } + if req.SortOrder == nil { + v := 0 + req.SortOrder = &v + } + + created, _, err := s.ipc.Database.ApprovalFlowNode.CreateApprovalFlowNodeDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.bumpFlowVersion(ctx) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "key": utilscore.DerefStr(created.Key), + "label": utilscore.DerefStr(created.Label), + "category_id": *req.CategoryID, + } + if created.ParentID != nil { + snapshot["parent_id"] = *created.ParentID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "flow_node", created.ID, + fmt.Sprintf("Создан узел «%s» (%s)", utilscore.DerefStr(created.Label), utilscore.DerefStr(created.Key)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return created, nil +} + +func (s *FlowNodesReg) UpdateFlowNodeHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req typescore.ApprovalFlowNode + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("id is required") + } + + ctx := r.Context() + + existing, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existing == nil { + return nil, errors.New("node not found") + } + + if req.ParentID != nil && (existing.ParentID == nil || *existing.ParentID != *req.ParentID) { + parent, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, *req.ParentID) + if err != nil { + return nil, err + } + if parent == nil { + return nil, errors.New("parent node not found") + } + if parent.CategoryID == nil || existing.CategoryID == nil || *parent.CategoryID != *existing.CategoryID { + return nil, errors.New("parent node belongs to a different category") + } + if err := s.checkNoCyclicReference(ctx, *req.ID, *req.ParentID); err != nil { + return nil, err + } + } + + if req.Key != nil && *req.Key != "" { + if existing.Key == nil || *existing.Key != *req.Key { + categoryID := existing.CategoryID + if req.CategoryID != nil { + categoryID = req.CategoryID + } + existingNodes, _, err := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{ + CategoryID: categoryID, + Key: req.Key, + }, + }) + if err != nil { + return nil, err + } + if len(existingNodes) > 0 { + return nil, fmt.Errorf("node with key '%s' already exists in this category", *req.Key) + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + + if req.Key != nil && !utilscore.StrEq(existing.Key, req.Key) { + changes = append(changes, fieldChange{"key", utilscore.DerefStr(existing.Key), *req.Key}) + } + if req.Label != nil && !utilscore.StrEq(existing.Label, req.Label) { + changes = append(changes, fieldChange{"label", utilscore.DerefStr(existing.Label), *req.Label}) + } + if req.DataKey != nil && !utilscore.StrEq(existing.DataKey, req.DataKey) { + changes = append(changes, fieldChange{"data_key", utilscore.DerefStr(existing.DataKey), *req.DataKey}) + } + if req.DataValue != nil && !utilscore.StrEq(existing.DataValue, req.DataValue) { + changes = append(changes, fieldChange{"data_value", utilscore.DerefStr(existing.DataValue), *req.DataValue}) + } + if req.MessageTemplate != nil && !utilscore.StrEq(existing.MessageTemplate, req.MessageTemplate) { + changes = append(changes, fieldChange{"message_template", utilscore.DerefStr(existing.MessageTemplate), *req.MessageTemplate}) + } + if req.CodeTemplate != nil && !utilscore.StrEq(existing.CodeTemplate, req.CodeTemplate) { + changes = append(changes, fieldChange{"code_template", utilscore.DerefStr(existing.CodeTemplate), *req.CodeTemplate}) + } + if req.SortOrder != nil && !utilscore.IntEq(existing.SortOrder, req.SortOrder) { + var oldVal interface{} + if existing.SortOrder != nil { + oldVal = *existing.SortOrder + } + changes = append(changes, fieldChange{"sort_order", oldVal, *req.SortOrder}) + } + if req.ParentID != nil && !utilscore.Uint64Eq(existing.ParentID, req.ParentID) { + var oldVal interface{} + if existing.ParentID != nil { + oldVal = *existing.ParentID + } + changes = append(changes, fieldChange{"parent_id", oldVal, *req.ParentID}) + } + + updated, _, err := s.ipc.Database.ApprovalFlowNode.UpdateApprovalFlowNodeDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.bumpFlowVersion(ctx) + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "flow_node", req.ID, + fmt.Sprintf("Изменён узел «%s»", utilscore.DerefStr(existing.Label)), + map[string]interface{}{"changes": changes}, + ) + } + } + + return updated, nil +} + +func (s *FlowNodesReg) DeleteFlowNodeHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req typescore.ApprovalFlowNode + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("id is required") + } + + ctx := r.Context() + + existing, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existing == nil { + return nil, errors.New("node not found") + } + + children, _, _ := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{ParentID: req.ID}, + }) + + err = s.ipc.Database.ApprovalFlowNode.DeleteApprovalFlowNodeDB(ctx, &req) + if err != nil { + return nil, err + } + + s.bumpFlowVersion(ctx) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "key": utilscore.DerefStr(existing.Key), + "label": utilscore.DerefStr(existing.Label), + "direct_children": len(children), + } + if existing.CategoryID != nil { + snapshot["category_id"] = *existing.CategoryID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "flow_node", req.ID, + fmt.Sprintf("Удалён узел «%s» (каскадно удалено дочерних: %d)", utilscore.DerefStr(existing.Label), len(children)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func (s *FlowNodesReg) SaveEntireTreeHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + categoryIDStr := chi.URLParam(r, "category_id") + categoryID, err := strconv.ParseUint(categoryIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid category_id") + } + + defer r.Body.Close() + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req struct { + Nodes []*typescore.ApprovalFlowNode `json:"nodes"` + } + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + ctx := r.Context() + + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, categoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("category not found") + } + + oldNodes, _, _ := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{CategoryID: &categoryID}, + }) + + if err := s.ipc.Database.ApprovalFlowNode.DeleteFlowNodesByCategoryIDDB(ctx, categoryID); err != nil { + return nil, err + } + + if err := s.saveNodesRecursive(ctx, req.Nodes, categoryID, nil); err != nil { + return nil, err + } + + s.bumpFlowVersion(ctx) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + categoryName := utilscore.DerefStr(category.Name) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "flow_tree", &categoryID, + fmt.Sprintf("Пересохранено дерево категории «%s» (было узлов: %d, стало: %d)", categoryName, len(oldNodes), countNodesRecursive(req.Nodes)), + map[string]interface{}{ + "category_id": categoryID, + "nodes_before": len(oldNodes), + "nodes_after": countNodesRecursive(req.Nodes), + }, + ) + } + + return true, nil +} + +func (s *FlowNodesReg) MoveFlowNodeHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid node id") + } + + defer r.Body.Close() + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req struct { + NewParentID *uint64 `json:"new_parent_id"` + NewSortOrder *int `json:"new_sort_order"` + } + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + ctx := r.Context() + + node, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, id) + if err != nil { + return nil, err + } + if node == nil { + return nil, errors.New("node not found") + } + + if req.NewParentID != nil { + if *req.NewParentID == id { + return nil, errors.New("node cannot be its own parent") + } + + parent, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, *req.NewParentID) + if err != nil { + return nil, err + } + if parent == nil { + return nil, errors.New("new parent node not found") + } + + if parent.CategoryID == nil || node.CategoryID == nil || *parent.CategoryID != *node.CategoryID { + return nil, errors.New("new parent belongs to a different category") + } + + if err := s.checkNoCyclicReference(ctx, id, *req.NewParentID); err != nil { + return nil, err + } + } + + update := &typescore.ApprovalFlowNode{ID: &id} + if req.NewParentID != nil { + update.ParentID = req.NewParentID + } + if req.NewSortOrder != nil { + update.SortOrder = req.NewSortOrder + } + + updated, _, err := s.ipc.Database.ApprovalFlowNode.UpdateApprovalFlowNodeDB(ctx, nil, update, true) + if err != nil { + return nil, err + } + + s.bumpFlowVersion(ctx) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + var oldParent interface{} + if node.ParentID != nil { + oldParent = *node.ParentID + } + metadata := map[string]interface{}{ + "old_parent_id": oldParent, + "new_parent_id": req.NewParentID, + "new_sort_order": req.NewSortOrder, + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "flow_node", &id, + fmt.Sprintf("Перемещён узел «%s»", utilscore.DerefStr(node.Label)), + metadata, + ) + } + + return updated, nil +} + +func (s *FlowNodesReg) DuplicateFlowNodeHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid node id") + } + + ctx := r.Context() + + original, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, id) + if err != nil { + return nil, err + } + if original == nil { + return nil, errors.New("node not found") + } + + allNodes, _, err := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{CategoryID: original.CategoryID}, + }) + if err != nil { + return nil, err + } + + descendants := s.collectDescendants(id, allNodes) + suffix := s.generateCopySuffix(ctx, original) + + newKey := *original.Key + suffix + newLabel := *original.Label + " (копия)" + + copyNode := &typescore.ApprovalFlowNode{ + CategoryID: original.CategoryID, + TopicID: original.TopicID, + ParentID: original.ParentID, + Key: &newKey, + Label: &newLabel, + DataKey: original.DataKey, + DataValue: original.DataValue, + IsInput: original.IsInput, + InputKey: original.InputKey, + InputHint: original.InputHint, + IsMultiSelect: original.IsMultiSelect, + MultiSelectKey: original.MultiSelectKey, + MultiSelectValue: original.MultiSelectValue, + TopicCode: original.TopicCode, + SortOrder: original.SortOrder, + MessageTemplate: original.MessageTemplate, + CodeTemplate: original.CodeTemplate, + } + + createdCopy, _, err := s.ipc.Database.ApprovalFlowNode.CreateApprovalFlowNodeDB(ctx, nil, copyNode, true) + if err != nil { + return nil, err + } + + if len(descendants) > 0 { + idMapping := map[uint64]uint64{ + id: *createdCopy.ID, + } + + sortedDescendants := s.sortByDepth(id, descendants, allNodes) + + for _, desc := range sortedDescendants { + descKey := *desc.Key + suffix + descCopy := &typescore.ApprovalFlowNode{ + CategoryID: desc.CategoryID, + TopicID: desc.TopicID, + Key: &descKey, + Label: desc.Label, + DataKey: desc.DataKey, + DataValue: desc.DataValue, + IsInput: desc.IsInput, + InputKey: desc.InputKey, + InputHint: desc.InputHint, + IsMultiSelect: desc.IsMultiSelect, + MultiSelectKey: desc.MultiSelectKey, + MultiSelectValue: desc.MultiSelectValue, + TopicCode: desc.TopicCode, + SortOrder: desc.SortOrder, + MessageTemplate: desc.MessageTemplate, + CodeTemplate: desc.CodeTemplate, + } + + if desc.ParentID != nil { + if newParentID, ok := idMapping[*desc.ParentID]; ok { + descCopy.ParentID = &newParentID + } + } + + createdDesc, _, err := s.ipc.Database.ApprovalFlowNode.CreateApprovalFlowNodeDB(ctx, nil, descCopy, true) + if err != nil { + return nil, err + } + if desc.ID != nil && createdDesc != nil && createdDesc.ID != nil { + idMapping[*desc.ID] = *createdDesc.ID + } + } + } + + s.bumpFlowVersion(ctx) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "flow_node", createdCopy.ID, + fmt.Sprintf("Продублирован узел «%s» (с потомками: %d)", utilscore.DerefStr(original.Label), len(descendants)), + map[string]interface{}{ + "duplicated_from": id, + "descendants": len(descendants), + }, + ) + } + + return createdCopy, nil +} + +func (s *FlowNodesReg) buildTreeFromNodes(nodes []*typescore.ApprovalFlowNode) []*typescore.ApprovalFlowNode { + nodeMap := make(map[uint64]*typescore.ApprovalFlowNode) + var roots []*typescore.ApprovalFlowNode + + for _, n := range nodes { + if n.ID != nil { + nodeMap[*n.ID] = n + } + } + + for _, n := range nodes { + if n.ParentID == nil { + roots = append(roots, n) + } else if parent, ok := nodeMap[*n.ParentID]; ok { + parent.Children = append(parent.Children, n) + } + } + + return roots +} + +func (s *FlowNodesReg) saveNodesRecursive(ctx context.Context, nodes []*typescore.ApprovalFlowNode, categoryID uint64, parentID *uint64) error { + for i, node := range nodes { + node.CategoryID = &categoryID + node.ParentID = parentID + + sortOrder := i + node.SortOrder = &sortOrder + + created, _, err := s.ipc.Database.ApprovalFlowNode.CreateApprovalFlowNodeDB(ctx, nil, node, true) + if err != nil { + return err + } + + if len(node.Children) > 0 { + if err := s.saveNodesRecursive(ctx, node.Children, categoryID, created.ID); err != nil { + return err + } + } + } + return nil +} + +// checkNoCyclicReference идёт вверх по родителям от newParentID — если +// встретит nodeID, значит перемещение создаёт цикл. +func (s *FlowNodesReg) checkNoCyclicReference(ctx context.Context, nodeID, newParentID uint64) error { + currentID := newParentID + visited := make(map[uint64]bool) + + for currentID != 0 { + if visited[currentID] { + break + } + visited[currentID] = true + + if currentID == nodeID { + return errors.New("cyclic reference detected: cannot move node under its own descendant") + } + + parent, err := s.ipc.Database.ApprovalFlowNode.GetFlowNodeByIDDB(ctx, currentID) + if err != nil || parent == nil { + break + } + if parent.ParentID == nil { + break + } + currentID = *parent.ParentID + } + + return nil +} + +func (s *FlowNodesReg) collectDescendants(rootID uint64, allNodes []*typescore.ApprovalFlowNode) []*typescore.ApprovalFlowNode { + childrenMap := make(map[uint64][]*typescore.ApprovalFlowNode) + for _, n := range allNodes { + if n.ParentID != nil { + childrenMap[*n.ParentID] = append(childrenMap[*n.ParentID], n) + } + } + + var result []*typescore.ApprovalFlowNode + queue := []uint64{rootID} + + for len(queue) > 0 { + current := queue[0] + queue = queue[1:] + + for _, child := range childrenMap[current] { + result = append(result, child) + if child.ID != nil { + queue = append(queue, *child.ID) + } + } + } + + return result +} + +func (s *FlowNodesReg) sortByDepth(rootID uint64, descendants, allNodes []*typescore.ApprovalFlowNode) []*typescore.ApprovalFlowNode { + depthMap := make(map[uint64]int) + depthMap[rootID] = 0 + + nodeMap := make(map[uint64]*typescore.ApprovalFlowNode) + for _, n := range allNodes { + if n.ID != nil { + nodeMap[*n.ID] = n + } + } + + for _, d := range descendants { + if d.ID == nil { + continue + } + depth := 0 + currentID := d.ID + for { + node, ok := nodeMap[*currentID] + if !ok || node.ParentID == nil { + break + } + depth++ + currentID = node.ParentID + if *currentID == rootID { + break + } + } + depthMap[*d.ID] = depth + } + + sorted := make([]*typescore.ApprovalFlowNode, len(descendants)) + copy(sorted, descendants) + for i := 0; i < len(sorted); i++ { + for j := i + 1; j < len(sorted); j++ { + depthI := 0 + depthJ := 0 + if sorted[i].ID != nil { + depthI = depthMap[*sorted[i].ID] + } + if sorted[j].ID != nil { + depthJ = depthMap[*sorted[j].ID] + } + if depthJ < depthI { + sorted[i], sorted[j] = sorted[j], sorted[i] + } + } + } + + return sorted +} + +func (s *FlowNodesReg) generateCopySuffix(ctx context.Context, original *typescore.ApprovalFlowNode) string { + if original.CategoryID == nil || original.Key == nil { + return "_copy" + } + + existing, _, err := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{CategoryID: original.CategoryID}, + }) + if err != nil { + return "_copy" + } + + baseKey := *original.Key + maxNum := 0 + + for _, n := range existing { + if n.Key == nil { + continue + } + key := *n.Key + if len(key) > len(baseKey) && key[:len(baseKey)] == baseKey { + suffix := key[len(baseKey):] + if len(suffix) >= 6 && suffix[:5] == "_copy" { + if len(suffix) > 5 { + numStr := suffix[6:] + if num, err := strconv.Atoi(numStr); err == nil && num > maxNum { + maxNum = num + } + } else if suffix == "_copy" { + if maxNum < 1 { + maxNum = 1 + } + } + } + } + } + + return fmt.Sprintf("_copy_%d", maxNum+1) +} + +func countNodesRecursive(nodes []*typescore.ApprovalFlowNode) int { + count := len(nodes) + for _, n := range nodes { + count += countNodesRecursive(n.Children) + } + return count +} + +func (s *FlowNodesReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/flow_nodes/handler.go----- + +File: handlers/flow_nodes/preview.go +Lines: 111 +-----BEGIN handlers/flow_nodes/preview.go----- +package nodeshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/telegram_service/approvalflow" + "encoding/json" + "errors" + "io" + "net/http" + "strconv" + + "github.com/go-chi/chi/v5" +) + +type previewFlowRequest struct { + // Collected — все data_key/data_value, накопленные по пути от корня + // дерева категории до узла, для которого считаем предпросмотр. + Collected map[string]string `json:"collected"` + // InitiatorName — необязательно, для более живого предпросмотра + // сообщения (по умолчанию подставляется тестовое имя). + InitiatorName string `json:"initiator_name"` +} + +type previewFlowResponse struct { + // Code — код темы, который реально будет использован для поиска + // ApprovalTopic при подаче заявки. Пусто, если по текущим данным + // код ещё нельзя посчитать (путь не завершён). + Code string `json:"code"` + // Message — как будет выглядеть уведомление согласующему (с HTML-разметкой, + // как оно уйдёт в Telegram). + Message string `json:"message"` + // Incomplete — true, если для расчёта кода не хватает данных + // (это не ошибка, а нормальная ситуация для промежуточного узла). + Incomplete bool `json:"incomplete"` + // TopicExists — есть ли уже в approval_topics тема с таким кодом. + TopicExists bool `json:"topic_exists"` + TopicID uint64 `json:"topic_id,omitempty"` + TopicName string `json:"topic_name,omitempty"` +} + +func (s *FlowNodesReg) PreviewFlowHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + categoryIDStr := chi.URLParam(r, "category_id") + categoryID, err := strconv.ParseUint(categoryIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid category_id") + } + + defer r.Body.Close() + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + + var req previewFlowRequest + if len(body) > 0 { + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + } + if req.Collected == nil { + req.Collected = map[string]string{} + } + if req.InitiatorName == "" { + req.InitiatorName = "Иван Иванов" + } + + ctx := r.Context() + + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, categoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("category not found") + } + + nodes, _, err := s.ipc.Database.ApprovalFlowNode.GetApprovalFlowNodesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalFlowNode{CategoryID: &categoryID}, + }) + if err != nil { + return nil, err + } + + dynamicTopic := approvalflow.NewDynamicTopic(category, nodes) + + resp := &previewFlowResponse{} + + code, err := dynamicTopic.TopicCodeFromCollected(req.Collected) + if err != nil { + // Ожидаемо для промежуточного узла: пути ещё не хватает данных. + resp.Incomplete = true + } else { + resp.Code = code + + existingTopic, exErr := s.ipc.Database.ApprovalTopic.GetApprovalTopicByCodeDB(ctx, code) + if exErr == nil && existingTopic != nil { + resp.TopicExists = true + if existingTopic.ID != nil { + resp.TopicID = *existingTopic.ID + } + if existingTopic.Name != nil { + resp.TopicName = *existingTopic.Name + } + } + } + + initiator := &typescore.User{FullName: &req.InitiatorName} + resp.Message = dynamicTopic.FormatApproverMessage(initiator, req.Collected) + + return resp, nil +} + +-----END handlers/flow_nodes/preview.go----- + +File: handlers/flow_nodes/router.go +Lines: 61 +-----BEGIN handlers/flow_nodes/router.go----- +package nodeshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type FlowNodesReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterFlowNodesRoutes регистрирует маршруты для управления узлами дерева. +// Дерево навигации принадлежит категории (category_id) — см. ApprovalFlowNode.CategoryID +// и Registry.LoadFromDB, которые строят Topic-интерфейс по категории + узлам. +func RegisterFlowNodesRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &FlowNodesReg{ + ipc: ipc, + } + + r.Route("/api/flow-nodes", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + // Получить дерево узлов для категории + handlers.RegisterRoute(r, http.MethodGet, "/category/{category_id}", s.GetFlowNodesByCategoryIDHandler) + + // CRUD операции с узлами + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateFlowNodeHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateFlowNodeHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteFlowNodeHandler) + + // Сохранить всё дерево целиком (для UI конструктора) + handlers.RegisterRoute(r, http.MethodPost, "/category/{category_id}/tree", s.SaveEntireTreeHandler) + + // Переместить узел (изменить порядок или родителя) — используется + // и обычным ↑/↓, и кнопками "поднять/опустить уровень" в новом UI. + handlers.RegisterRoute(r, http.MethodPost, "/{id}/move", s.MoveFlowNodeHandler) + + // Дублировать узел с детьми + handlers.RegisterRoute(r, http.MethodPost, "/{id}/duplicate", s.DuplicateFlowNodeHandler) + + // НОВОЕ: живой предпросмотр кода темы и сообщения согласующему + // для конкретного пути по дереву — см. preview.go + handlers.RegisterRoute(r, http.MethodPost, "/category/{category_id}/preview", s.PreviewFlowHandler) + + // НОВОЕ: кнопка "Обновить бота" — форсирует бамп версии дерева тем, + // бот подхватит на ближайшем тике фонового воркера — см. reload.go + handlers.RegisterRoute(r, http.MethodPost, "/reload-bot", s.ReloadBotHandler) + + // Получить узел по ID + handlers.RegisterRoute(r, http.MethodGet, "/{id}", s.GetFlowNodeByIDHandler) + }) + + return nil +} + +-----END handlers/flow_nodes/router.go----- + +File: handlers/flow_nodes/utils.go +Lines: 20 +-----BEGIN handlers/flow_nodes/utils.go----- +package nodeshandler + +import ( + "context" + "fmt" + "net/http" + "time" +) + +const flowVersionRedisKey = "approval_flow:version" + +func (s *FlowNodesReg) bumpFlowVersion(ctx context.Context) { + version := fmt.Sprintf("%d", time.Now().UnixNano()) + _ = s.ipc.RedisClient.Set(ctx, flowVersionRedisKey, version, 24*time.Hour) +} + +func (s *FlowNodesReg) ReloadBotHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + s.bumpFlowVersion(r.Context()) + return true, nil +} + +-----END handlers/flow_nodes/utils.go----- + +File: handlers/middleware.go +Lines: 328 +-----BEGIN handlers/middleware.go----- +package handlers + +import ( + configcore "bitrix_balancer_api/core/config" + dbcore "bitrix_balancer_api/core/db/methods" + redismodule "bitrix_balancer_api/core/lib/internally/redis" + "bitrix_balancer_api/core/securecore" + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/core/variables" + "context" + "encoding/json" + "errors" + "fmt" + "net/http" + "strconv" + "strings" + "time" + + "github.com/sirupsen/logrus" +) + +// JWTVerifier middleware для проверки JWT токена и соответствия IP +func JWTVerifier(cfg *configcore.Config, adminDB dbcore.AdminDBI, redisModule *redismodule.ModuleRedis) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if cfg.Secrets.AuthJWT.AdminSecret == "" { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + }).Error("JWTVerifier: AdminSecret is empty") + http.Error(w, "Internal server error", http.StatusInternalServerError) + return + } + + authHeader := r.Header.Get("Authorization") + if authHeader == "" { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + }).Warn("JWTVerifier: Authorization header is empty") + http.Error(w, "Unauthorized", http.StatusUnauthorized) + return + } + + deviceID := r.Header.Get("x-device-id") + if deviceID == "" { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + }).Warn("JWTVerifier: x-device-id header is empty") + http.Error(w, "Unauthorized device", http.StatusUnauthorized) + return + } + + if redisModule == nil { + logrus.Error("JWTVerifier: Redis storage not initialized") + http.Error(w, "Internal server error: Redis storage not initialized", http.StatusInternalServerError) + return + } + + parts := strings.Split(authHeader, " ") + if len(parts) != 2 || parts[0] != "Bearer" { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "auth_header": authHeader, + }).Warn("JWTVerifier: Invalid authorization header format") + http.Error(w, "Invalid authorization header", http.StatusUnauthorized) + return + } + tokenString := parts[1] + + _, claims, err := securecore.VerifyToken(tokenString, cfg.Secrets.AuthJWT.AdminSecret) + if err != nil { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "error": err.Error(), + }).Warn("JWTVerifier: Token verification failed") + http.Error(w, "Invalid token", http.StatusUnauthorized) + return + } + + userIDFloat, ok := claims[securecore.IDContextKey.String()].(float64) + if !ok { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + }).Warn("JWTVerifier: Missing user_id in token claims") + http.Error(w, "Invalid token: missing user_id", http.StatusUnauthorized) + return + } + userID := uint64(userIDFloat) + + adminList, _, errW := adminDB.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ + ID: &userID, + IsBlocked: utilscore.PointerToBool(false), + }, + }) + if errW != nil || len(adminList) == 0 { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "user_id": userID, + "error": errW, + }).Warn("JWTVerifier: Admin not found or blocked") + http.Error(w, "Admin not found or blocked", http.StatusUnauthorized) + return + } + + if adminList[0].IsBlocked == nil || *adminList[0].IsBlocked { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "user_id": userID, + }).Warn("JWTVerifier: Account is blocked") + http.Error(w, "Forbidden: account is blocked", http.StatusUnauthorized) + return + } + + ctx := context.WithValue(r.Context(), securecore.IDContextKey, userID) + + sessionJSON, err := redisModule.Get(ctx, fmt.Sprintf("%s:admin:%d", variables.RedisPathUserAuthSessions, userID)) + if err != nil || sessionJSON == "" { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "user_id": userID, + "error": err, + }).Warn("JWTVerifier: User session not found in Redis") + http.Error(w, "User session not found. Please authorize again", http.StatusUnauthorized) + return + } + + var session typescore.UsersSessions + if err := json.Unmarshal([]byte(sessionJSON), &session); err != nil { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "user_id": userID, + "error": err.Error(), + }).Warn("JWTVerifier: Failed to unmarshal session") + http.Error(w, "Failed to get user session data. Please authorize again", http.StatusUnauthorized) + return + } + + if !securecore.FindDeviceID(session.AuthorizedDevices, deviceID) { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "user_id": userID, + "device_id": deviceID, + }).Warn("JWTVerifier: Device not authorized") + http.Error(w, "Unauthorized device", http.StatusUnauthorized) + return + } + + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "user_id": userID, + "device_id": deviceID, + }).Debug("JWTVerifier: Request authorized") + + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +// AccessCodeVerifier middleware для проверки Access Code для валидного фронта +func AccessCodeVerifier(cfg *configcore.Config) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + // 🆕 Логируем начало проверки + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "method": r.Method, + "remote": r.RemoteAddr, + }).Debug("AccessCodeVerifier: Starting verification") + + // Проверка 1: Секреты в конфиге + if cfg.Secrets.ApiPublicAdmin == "" || cfg.Secrets.ApiPrivateAdmin == "" { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "api_public_empty": cfg.Secrets.ApiPublicAdmin == "", + "api_private_empty": cfg.Secrets.ApiPrivateAdmin == "", + }).Error("AccessCodeVerifier: API secrets not configured") + http.Error(w, "Internal server error", http.StatusInternalServerError) + return + } + + // Получаем заголовки + authHeader := r.Header.Get("ApiKey") + timestampStr := r.Header.Get("X-Timestamp") + deviceID := r.Header.Get("x-device-id") + + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "has_api_key": authHeader != "", + "has_timestamp": timestampStr != "", + "device_id": deviceID, + }).Debug("AccessCodeVerifier: Headers received") + + // Проверка 2: Наличие заголовков + if authHeader == "" || timestampStr == "" { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "api_key_empty": authHeader == "", + "timestamp_empty": timestampStr == "", + "all_headers": r.Header, + }).Warn("AccessCodeVerifier: Missing required headers") + http.Error(w, "Unauthorized client", http.StatusUnauthorized) + return + } + + // Проверка 3: Парсинг timestamp + timestampUnix, err := strconv.ParseInt(timestampStr, 10, 64) + if err != nil { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "timestamp": timestampStr, + "error": err.Error(), + }).Warn("AccessCodeVerifier: Invalid timestamp format") + http.Error(w, "Invalid timestamp", http.StatusBadRequest) + return + } + + // Конвертируем Unix timestamp в time.Time + timestampTime := time.Unix(timestampUnix, 0).UTC() + now := time.Now().UTC() + + // Округляем время до минут + timestampTimeRounded := time.Date( + timestampTime.Year(), timestampTime.Month(), timestampTime.Day(), + timestampTime.Hour(), timestampTime.Minute(), 0, 0, time.UTC, + ) + nowRounded := time.Date( + now.Year(), now.Month(), now.Day(), + now.Hour(), now.Minute(), 0, 0, time.UTC, + ) + + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "timestamp_received": timestampTime.Format(time.RFC3339), + "timestamp_rounded": timestampTimeRounded.Format(time.RFC3339), + "now": now.Format(time.RFC3339), + "now_rounded": nowRounded.Format(time.RFC3339), + }).Debug("AccessCodeVerifier: Timestamp parsed") + + // Проверка 4: Timestamp не старше 3 минут + threeMinutesAgo := nowRounded.Add(-3 * time.Minute) + + if timestampTimeRounded.Before(threeMinutesAgo) { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "timestamp": timestampTimeRounded.Format(time.RFC3339), + "three_minutes_ago": threeMinutesAgo.Format(time.RFC3339), + "now": nowRounded.Format(time.RFC3339), + }).Warn("AccessCodeVerifier: Timestamp expired") + http.Error(w, "Timestamp expired", http.StatusUnauthorized) + return + } + + // Проверка 5: Timestamp не в будущем + if timestampTimeRounded.After(nowRounded) { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "timestamp": timestampTimeRounded.Format(time.RFC3339), + "now": nowRounded.Format(time.RFC3339), + }).Warn("AccessCodeVerifier: Timestamp in future") + http.Error(w, "Timestamp in future", http.StatusUnauthorized) + return + } + + // Проверка 6: Генерация и сравнение подписи + expectedSignature := utilscore.GenerateHMACSignature( + cfg.Secrets.ApiPublicAdmin, + timestampStr, + cfg.Secrets.ApiPrivateAdmin, + ) + + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "public_key": cfg.Secrets.ApiPublicAdmin[:min(10, len(cfg.Secrets.ApiPublicAdmin))] + "...", + "timestamp": timestampStr, + "expected_signature": expectedSignature[:min(20, len(expectedSignature))] + "...", + "received_signature": authHeader[:min(20, len(authHeader))] + "...", + "signatures_match": expectedSignature == authHeader, + }).Debug("AccessCodeVerifier: Comparing signatures") + + // Безопасное сравнение + if !utilscore.HmacEquals(expectedSignature, authHeader) { + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + "expected_signature": expectedSignature, + "received_signature": authHeader, + "expected_length": len(expectedSignature), + "received_length": len(authHeader), + }).Warn("AccessCodeVerifier: Signature mismatch") + http.Error(w, "Unauthorized client", http.StatusUnauthorized) + return + } + + logrus.WithFields(logrus.Fields{ + "path": r.URL.Path, + }).Debug("AccessCodeVerifier: Verification successful") + + ctx := context.WithValue(r.Context(), securecore.AccessContextKey, authHeader) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +// GetIDFromContext извлекает user id из контекста +func GetIDFromContext(ctx context.Context) (uint64, error) { + address, ok := ctx.Value(securecore.IDContextKey).(uint64) + if !ok { + return 0, errors.New("no id found in context") + } + return address, nil +} + +// GetIPFromContext извлекает user ip из контекста +func GetIPFromContext(ctx context.Context) (string, error) { + address, ok := ctx.Value(securecore.IpContextKey).(string) + if !ok { + return "", errors.New("no ip found in context") + } + return address, nil +} + +// min возвращает минимальное из двух int +func min(a, b int) int { + if a < b { + return a + } + return b +} + +-----END handlers/middleware.go----- + +File: handlers/notification/handlers.go +Lines: 306 +-----BEGIN handlers/notification/handlers.go----- +package notificationshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + typesm "bitrix_balancer_api/rest_admin_service/types" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/go-chi/chi/v5" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" +) + +type NotificationReg struct { + ipc *typesm.InternalProviderControl +} + +func (s *NotificationReg) CreateNotificationHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + body, err := io.ReadAll(r.Body) + if err != nil { + return nil, err + } + defer r.Body.Close() + + var req typescore.CreateNotificationReq + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + if req.Title == "" || req.MessageHTML == "" { + return nil, errors.New("title and message_html are required") + } + + ctx := r.Context() + + recipients, err := s.resolveRecipients(ctx, req.Targets) + if err != nil { + return nil, err + } + if len(recipients) == 0 { + return nil, errors.New("no recipients matched the given filters") + } + + targetFiltersJSON, err := json.Marshal(req.Targets) + if err != nil { + return nil, err + } + targetFiltersStr := string(targetFiltersJSON) + + status := "sending" + totalCount := len(recipients) + notification := &typescore.Notification{ + Title: &req.Title, + MessageHTML: &req.MessageHTML, + PhotoBase64: req.PhotoBase64, + PhotoFileName: req.PhotoFileName, + TargetFilters: &targetFiltersStr, + Status: &status, + TotalCount: &totalCount, + } + + notification, err = s.ipc.Database.Notification.CreateNotificationDB(ctx, notification) + if err != nil { + return nil, err + } + + pendingStatus := "pending" + recipientRows := make([]*typescore.NotificationRecipient, 0, len(recipients)) + for _, u := range recipients { + recipientRows = append(recipientRows, &typescore.NotificationRecipient{ + NotificationID: notification.ID, + UserID: u.ID, + Status: &pendingStatus, + }) + } + if err := s.ipc.Database.Notification.CreateNotificationRecipientsDB(ctx, recipientRows); err != nil { + return nil, err + } + + sentCount, failedCount := s.sendToRecipients(ctx, notification, recipients) + + finalStatus := "completed" + notification.Status = &finalStatus + notification.SentCount = &sentCount + notification.FailedCount = &failedCount + if err := s.ipc.Database.Notification.UpdateNotificationDB(ctx, notification); err != nil { + logrus.Warnf("CreateNotificationHandler: failed to update final status: %v", err) + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "notification", notification.ID, + fmt.Sprintf("Отправлена рассылка «%s» (получателей: %d, отправлено: %d, ошибок: %d)", + req.Title, totalCount, sentCount, failedCount), + map[string]interface{}{ + "title": req.Title, + "total_count": totalCount, + "sent_count": sentCount, + "failed_count": failedCount, + "target_filters": req.Targets, + }, + ) + } + + return notification, nil +} + +// resolveRecipients объединяет пользователей из всех критериев без дублей +func (s *NotificationReg) resolveRecipients(ctx context.Context, filters typescore.TargetFilters) ([]*typescore.User, error) { + usersMap := make(map[uint64]*typescore.User) + + addUsers := func(list []*typescore.User) { + for _, u := range list { + if u.ID != nil { + usersMap[*u.ID] = u + } + } + } + + if len(filters.UserIDs) > 0 { + users, err := s.ipc.Database.User.GetUsersByIDsDB(ctx, filters.UserIDs) + if err != nil { + return nil, err + } + addUsers(users) + } + + if len(filters.RoleIDs) > 0 { + users, _, err := s.ipc.Database.User.GetUsersListByRoleIDsDB(ctx, typescore.ListDbOptions{}, filters.RoleIDs) + if err != nil { + return nil, err + } + addUsers(users) + } + + if len(filters.RoleTypeFlags) > 0 { + users, err := s.ipc.Database.User.GetUsersByRoleFlagsDB(ctx, filters.RoleTypeFlags) + if err != nil { + return nil, err + } + addUsers(users) + } + + if len(filters.DepartmentIDs) > 0 { + users, err := s.ipc.Database.User.GetUsersByDepartmentIDsDB(ctx, filters.DepartmentIDs) + if err != nil { + return nil, err + } + addUsers(users) + } + + result := make([]*typescore.User, 0, len(usersMap)) + for _, u := range usersMap { + if u.IsBlocked != nil && *u.IsBlocked { + continue + } + result = append(result, u) + } + return result, nil +} + +// sendToRecipients рассылает сообщение всем найденным пользователям и фиксирует результат по каждому +func (s *NotificationReg) sendToRecipients(ctx context.Context, n *typescore.Notification, users []*typescore.User) (sent int, failed int) { + pendingRecipients, err := s.ipc.Database.Notification.GetNotificationRecipientsDB(ctx, *n.ID) + if err != nil { + logrus.Errorf("sendToRecipients: failed to load recipients: %v", err) + return 0, len(users) + } + + recipientByUserID := make(map[uint64]*typescore.NotificationRecipient) + for _, r := range pendingRecipients { + if r.UserID != nil { + recipientByUserID[*r.UserID] = r + } + } + + sentStatus := "sent" + failedStatus := "failed" + + for _, u := range users { + if u.TelegramID == nil { + continue + } + rec, ok := recipientByUserID[*u.ID] + if !ok { + continue + } + + var sendErr error + var msgID int + + if n.PhotoBase64 != nil && *n.PhotoBase64 != "" { + fileName := "notification.jpg" + if n.PhotoFileName != nil { + fileName = *n.PhotoFileName + } + sentMsg, err := s.ipc.TGBotClient.SendPhoto(*u.TelegramID, *n.PhotoBase64, *n.MessageHTML) + if err != nil { + sendErr = err + } else { + msgID = sentMsg.MessageID + } + _ = fileName + } else { + sentMsg, err := s.ipc.TGBotClient.Send(*u.TelegramID, *n.MessageHTML) + if err != nil { + sendErr = err + } else { + msgID = sentMsg.MessageID + } + } + + if sendErr != nil { + errStr := sendErr.Error() + rec.Status = &failedStatus + rec.ErrorMessage = &errStr + failed++ + } else { + rec.Status = &sentStatus + rec.TelegramMessageID = &msgID + sent++ + } + + if err := s.ipc.Database.Notification.UpdateNotificationRecipientDB(ctx, rec); err != nil { + logrus.Warnf("sendToRecipients: failed to update recipient status: %v", err) + } + } + + return sent, failed +} + +// GetNotificationListHandler — история отправленных уведомлений +func (s *NotificationReg) GetNotificationListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + notificationParams := &typescore.Notification{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, notificationParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: notificationParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + list, total, err := s.ipc.Database.Notification.GetNotificationsListDB(r.Context(), options) + if err != nil { + return nil, err + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: list, + }, nil +} + +// GetNotificationByIDHandler — детали конкретной рассылки с постатейной историей доставки +func (s *NotificationReg) GetNotificationByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid notification id") + } + + ctx := r.Context() + notification, err := s.ipc.Database.Notification.GetNotificationByIDDB(ctx, id) + if err != nil { + return nil, err + } + if notification == nil { + return nil, errors.New("notification not found") + } + + recipients, err := s.ipc.Database.Notification.GetNotificationRecipientsDB(ctx, id) + if err == nil { + notification.Recipients = recipients + } + + return notification, nil +} + +func (s *NotificationReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/notification/handlers.go----- + +File: handlers/notification/routes.go +Lines: 26 +-----BEGIN handlers/notification/routes.go----- +package notificationshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +func RegisterNotificationRoutes(r chi.Router, ipc *typesm.InternalProviderControl) error { + s := &NotificationReg{ipc: ipc} + + r.Route("/api/notifications", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateNotificationHandler) + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetNotificationListHandler) + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetNotificationByIDHandler, + })) + }) + + return nil +} + +-----END handlers/notification/routes.go----- + +File: handlers/permission/handlers.go +Lines: 648 +-----BEGIN handlers/permission/handlers.go----- +package permissionshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + + "github.com/go-chi/chi/v5" +) + +// GetPermissionsListHandler Получение списка прав +// @Summary Получение списка прав +// @Description Получение списка прав ролей с пагинацией и фильтрацией +// @Tags permissions +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param role_id query integer false "Фильтр по роли" +// @Param action query string false "Фильтр по действию (create, read, update, delete, approve, revoke)" +// @Param topic_category_id query integer false "Фильтр по категории тем" +// @Param topic_id query integer false "Фильтр по теме" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/permissions [get] +func (s *PermissionsReg) GetPermissionsListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + permissionParams := &typescore.Permission{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, permissionParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: permissionParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + permissionsDbLst, total, errW := s.ipc.Database.Permission.GetPermissionsListDB(ctx, options) + if errW != nil { + return nil, errW + } + + s.enrichPermissionsBatch(ctx, permissionsDbLst) + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: permissionsDbLst, + }, nil +} + +// GetPermissionsByRoleIDHandler Получение всех прав для роли +// @Summary Получение прав по роли +// @Description Получение списка всех прав для указанной роли +// @Tags permissions +// @Accept json +// @Produce json +// @Param role_id path integer true "ID роли" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Роль не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/permissions/by-role/{role_id} [get] +func (s *PermissionsReg) GetPermissionsByRoleIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + roleIDStr := chi.URLParam(r, "role_id") + if roleIDStr == "" { + return nil, errors.New("role_id is required") + } + + roleID, err := strconv.ParseUint(roleIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid role_id") + } + + ctx := r.Context() + + role, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, roleID) + if err != nil { + return nil, err + } + if role == nil { + return nil, errors.New("role not found") + } + + permissions, _, err := s.ipc.Database.Permission.GetPermissionsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Permission{RoleID: &roleID}, + }) + if err != nil { + return nil, err + } + + s.enrichPermissionsBatch(ctx, permissions) + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(permissions)), + Data: permissions, + }, nil +} + +// enrichPermissionsBatch пакетно подгружает роли, категории и темы для списка прав +func (s *PermissionsReg) enrichPermissionsBatch(ctx context.Context, permissions []*typescore.Permission) { + if len(permissions) == 0 { + return + } + + roleIDsSet := make(map[uint64]struct{}) + categoryIDsSet := make(map[uint64]struct{}) + topicIDsSet := make(map[uint64]struct{}) + + for _, p := range permissions { + if p.RoleID != nil { + roleIDsSet[*p.RoleID] = struct{}{} + } + if p.TopicCategoryID != nil { + categoryIDsSet[*p.TopicCategoryID] = struct{}{} + } + if p.TopicID != nil { + topicIDsSet[*p.TopicID] = struct{}{} + } + } + + roleIDs := make([]uint64, 0, len(roleIDsSet)) + for id := range roleIDsSet { + roleIDs = append(roleIDs, id) + } + categoryIDs := make([]uint64, 0, len(categoryIDsSet)) + for id := range categoryIDsSet { + categoryIDs = append(categoryIDs, id) + } + topicIDs := make([]uint64, 0, len(topicIDsSet)) + for id := range topicIDsSet { + topicIDs = append(topicIDs, id) + } + + rolesMap := make(map[uint64]*typescore.Role) + if roles, err := s.ipc.Database.Role.GetRolesByIDsDB(ctx, roleIDs); err == nil { + for _, role := range roles { + if role.ID != nil { + rolesMap[*role.ID] = role + } + } + } + + categoriesMap := make(map[uint64]*typescore.ApprovalTopicCategory) + if categories, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoriesByIDsDB(ctx, categoryIDs); err == nil { + for _, c := range categories { + if c.ID != nil { + categoriesMap[*c.ID] = c + } + } + } + + topicsMap := make(map[uint64]*typescore.ApprovalTopic) + if topics, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsByIDsDB(ctx, topicIDs); err == nil { + for _, t := range topics { + if t.ID != nil { + topicsMap[*t.ID] = t + } + } + } + + for _, p := range permissions { + if p.RoleID != nil { + if role, ok := rolesMap[*p.RoleID]; ok { + p.Role = role + } + } + if p.TopicCategoryID != nil { + if cat, ok := categoriesMap[*p.TopicCategoryID]; ok { + p.TopicCategory = cat + } + } + if p.TopicID != nil { + if topic, ok := topicsMap[*p.TopicID]; ok { + p.Topic = topic + } + } + } +} + +// GetPermissionByIDHandler Получение права по ID +// @Summary Получение права по ID +// @Description Получение детальной информации о праве по его ID +// @Tags permissions +// @Accept json +// @Produce json +// @Param id path integer true "ID права" +// @Success 200 {object} typescore.Permission "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Право не найдено" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/permissions/{id} [get] +func (s *PermissionsReg) GetPermissionByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("permission id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid permission id") + } + + ctx := r.Context() + permissions, _, err := s.ipc.Database.Permission.GetPermissionsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Permission{ID: &id}, + }) + if err != nil { + return nil, err + } + if len(permissions) == 0 { + return nil, errors.New("permission not found") + } + + permission := permissions[0] + s.enrichPermission(ctx, permission) + + return permission, nil +} + +// CreatePermissionHandler Создание права +// @Summary Создание права +// @Description Назначение права на действие для роли +// @Tags permissions +// @Accept json +// @Produce json +// @Param request body typescore.Permission true "Данные права" +// @Success 200 {object} typescore.Permission "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Роль, категория или тема не найдены" +// @Failure 409 {object} handlers.ErrorResponse "Такое право уже существует" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/permissions [post] +func (s *PermissionsReg) CreatePermissionHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreatePermissionHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Permission + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.RoleID == nil { + return nil, errors.New("role_id is required") + } + if req.Action == nil || *req.Action == "" { + return nil, errors.New("action is required") + } + + if !isValidAction(*req.Action) { + return nil, errors.New("invalid action: must be one of create, read, update, delete, approve, revoke, observe") + } + + ctx := r.Context() + + role, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, *req.RoleID) + if err != nil { + return nil, err + } + if role == nil { + return nil, errors.New("role not found") + } + + if req.TopicCategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.TopicCategoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("topic category not found") + } + } + + if req.TopicID != nil { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.TopicID) + if err != nil { + return nil, err + } + if topic == nil { + return nil, errors.New("topic not found") + } + + if req.TopicCategoryID != nil && topic.CategoryID != nil { + if *topic.CategoryID != *req.TopicCategoryID { + return nil, errors.New("topic does not belong to the specified category") + } + } + } + + existingPermissions, _, err := s.ipc.Database.Permission.GetPermissionsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Permission{ + RoleID: req.RoleID, + TopicCategoryID: req.TopicCategoryID, + TopicID: req.TopicID, + Action: req.Action, + }, + }) + if err != nil { + return nil, err + } + if len(existingPermissions) > 0 { + return nil, errors.New("this permission already exists") + } + + createdPermission, _, err := s.ipc.Database.Permission.CreatePermissionDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichPermission(ctx, createdPermission) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "role_id": *createdPermission.RoleID, + "action": utilscore.DerefStr(createdPermission.Action), + } + if createdPermission.TopicCategoryID != nil { + snapshot["topic_category_id"] = *createdPermission.TopicCategoryID + } + if createdPermission.TopicID != nil { + snapshot["topic_id"] = *createdPermission.TopicID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "permission", createdPermission.ID, + fmt.Sprintf("Выдано право «%s» роли «%s» на %s", utilscore.DerefStr(createdPermission.Action), roleLabel(createdPermission.Role), scopeLabel(createdPermission)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return createdPermission, nil +} + +// UpdatePermissionHandler Обновление права +// @Summary Обновление права +// @Description Обновление данных существующего права +// @Tags permissions +// @Accept json +// @Produce json +// @Param request body typescore.Permission true "Данные права" +// @Success 200 {object} typescore.Permission "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Право не найдено" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/permissions [put] +func (s *PermissionsReg) UpdatePermissionHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdatePermissionHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Permission + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("permission id is required") + } + + ctx := r.Context() + + existingPermissions, _, err := s.ipc.Database.Permission.GetPermissionsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Permission{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingPermissions) == 0 { + return nil, errors.New("permission not found") + } + existing := existingPermissions[0] + + if req.Action != nil && *req.Action != "" { + if !isValidAction(*req.Action) { + return nil, errors.New("invalid action: must be one of create, read, update, delete, approve, revoke, observe") + } + } + + if req.RoleID != nil { + if existing.RoleID == nil || *existing.RoleID != *req.RoleID { + role, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, *req.RoleID) + if err != nil { + return nil, err + } + if role == nil { + return nil, errors.New("role not found") + } + } + } + + if req.TopicCategoryID != nil { + if existing.TopicCategoryID == nil || *existing.TopicCategoryID != *req.TopicCategoryID { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.TopicCategoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("topic category not found") + } + } + } + + if req.TopicID != nil { + if existing.TopicID == nil || *existing.TopicID != *req.TopicID { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.TopicID) + if err != nil { + return nil, err + } + if topic == nil { + return nil, errors.New("topic not found") + } + + categoryIDToCheck := req.TopicCategoryID + if categoryIDToCheck == nil { + categoryIDToCheck = existing.TopicCategoryID + } + if categoryIDToCheck != nil && topic.CategoryID != nil && *topic.CategoryID != *categoryIDToCheck { + return nil, errors.New("topic does not belong to the specified category") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + + if req.Action != nil && !utilscore.StrEq(existing.Action, req.Action) { + changes = append(changes, fieldChange{"action", utilscore.DerefStr(existing.Action), *req.Action}) + } + if req.RoleID != nil && !utilscore.Uint64Eq(existing.RoleID, req.RoleID) { + var oldVal interface{} + if existing.RoleID != nil { + oldVal = *existing.RoleID + } + changes = append(changes, fieldChange{"role_id", oldVal, *req.RoleID}) + } + if req.TopicCategoryID != nil && !utilscore.Uint64Eq(existing.TopicCategoryID, req.TopicCategoryID) { + var oldVal interface{} + if existing.TopicCategoryID != nil { + oldVal = *existing.TopicCategoryID + } + changes = append(changes, fieldChange{"topic_category_id", oldVal, *req.TopicCategoryID}) + } + if req.TopicID != nil && !utilscore.Uint64Eq(existing.TopicID, req.TopicID) { + var oldVal interface{} + if existing.TopicID != nil { + oldVal = *existing.TopicID + } + changes = append(changes, fieldChange{"topic_id", oldVal, *req.TopicID}) + } + + updatedPermission, _, err := s.ipc.Database.Permission.UpdatePermissionDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichPermission(ctx, updatedPermission) + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "permission", req.ID, + fmt.Sprintf("Изменено право роли «%s»", roleLabel(updatedPermission.Role)), + map[string]interface{}{"changes": changes}, + ) + } + } + + return updatedPermission, nil +} + +// DeletePermissionHandler Удаление права +// @Summary Удаление права +// @Description Удаление права по ID +// @Tags permissions +// @Accept json +// @Produce json +// @Param request body typescore.Permission true "ID права для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Право не найдено" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/permissions [delete] +func (s *PermissionsReg) DeletePermissionHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeletePermissionHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Permission + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("permission id is required") + } + + ctx := r.Context() + + existingPermissions, _, err := s.ipc.Database.Permission.GetPermissionsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Permission{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingPermissions) == 0 { + return nil, errors.New("permission not found") + } + existing := existingPermissions[0] + s.enrichPermission(ctx, existing) + + err = s.ipc.Database.Permission.DeletePermissionDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "action": utilscore.DerefStr(existing.Action), + } + if existing.RoleID != nil { + snapshot["role_id"] = *existing.RoleID + } + if existing.TopicCategoryID != nil { + snapshot["topic_category_id"] = *existing.TopicCategoryID + } + if existing.TopicID != nil { + snapshot["topic_id"] = *existing.TopicID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "permission", req.ID, + fmt.Sprintf("Отозвано право «%s» у роли «%s» на %s", utilscore.DerefStr(existing.Action), roleLabel(existing.Role), scopeLabel(existing)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +// enrichPermission подгружает связанные данные для права +func (s *PermissionsReg) enrichPermission(ctx context.Context, perm *typescore.Permission) { + if perm == nil { + return + } + + if perm.RoleID != nil { + role, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, *perm.RoleID) + if err == nil && role != nil { + perm.Role = role + } + } + + if perm.TopicCategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *perm.TopicCategoryID) + if err == nil && category != nil { + perm.TopicCategory = category + } + } + + if perm.TopicID != nil { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *perm.TopicID) + if err == nil && topic != nil { + perm.Topic = topic + } + } +} + +// isValidAction проверяет валидность действия +func isValidAction(action string) bool { + validActions := map[string]bool{ + "create": true, + "read": true, + "update": true, + "delete": true, + "approve": true, + "revoke": true, + "observe": true, + } + return validActions[action] +} + +func roleLabel(role *typescore.Role) string { + if role == nil || role.Name == nil { + return "—" + } + return *role.Name +} + +func scopeLabel(perm *typescore.Permission) string { + if perm.Topic != nil && perm.Topic.Name != nil { + return "тему «" + *perm.Topic.Name + "»" + } + if perm.TopicCategory != nil && perm.TopicCategory.Name != nil { + return "категорию «" + *perm.TopicCategory.Name + "»" + } + return "все темы" +} + +func (s *PermissionsReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/permission/handlers.go----- + +File: handlers/permission/routes.go +Lines: 43 +-----BEGIN handlers/permission/routes.go----- +package permissionshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type PermissionsReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterPermissionRoutes регистрирует маршруты для группы permissions +func RegisterPermissionRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &PermissionsReg{ + ipc: ipc, + } + + r.Route("/api/permissions", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetPermissionsListHandler) + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreatePermissionHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdatePermissionHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeletePermissionHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetPermissionByIDHandler, + })) + + r.Get("/by-role/{role_id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetPermissionsByRoleIDHandler, + })) + }) + + return nil +} + +-----END handlers/permission/routes.go----- + +File: handlers/profile/handlers.go +Lines: 102 +-----BEGIN handlers/profile/handlers.go----- +package profilehandler + +import ( + "bitrix_balancer_api/core/securecore" + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + "encoding/json" + "errors" + "github.com/sirupsen/logrus" + "io" + "net/http" +) + +// GetProfileHandler Получение профиля пользователя +// @Summary Получение профиля пользователя +// @Description Получение профиля пользователя +// @Tags profile +// @Accept json +// @Produce json +// @Success 200 {object} typescore.Admin +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/admin/profile [get] +func (h *ProfileReg) GetProfileHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + userID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, err + } + userObjBody := &typescore.Admin{ + ID: &userID, + } + + usersList, _, err := h.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{Filtering: userObjBody}) + if err != nil { + return nil, err + } + + if usersList == nil || len(usersList) == 0 { + return nil, errors.New("no users found") + } + + return usersList[0], nil +} + +// UpdateProfileHandler Обновление профиля пользователя +// @Summary Обновление профиля пользователя +// @Description Обновление профиля пользователя +// @Tags profile +// @Accept json +// @Produce json +// @Param request body typescore.AdminReq true "Запрос" +// @Success 200 {object} typescore.Admin +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/admin/profile [put] +func (h *ProfileReg) UpdateProfileHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 error LoginByPassword: ReadAll: ", err) + return nil, err + } + + var req typescore.AdminReq + if err := json.Unmarshal(body, &req); err != nil { + return nil, err + } + + userID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, err + } + userObjBody := &typescore.Admin{ + ID: &userID, + } + + if req.Password != nil { + err := utilscore.ValidatePassword(*req.Password) + if err != nil { + return nil, err + } + + hash, err := securecore.HashPassword(req.Password) + + if err != nil { + return nil, err + } + userObjBody.PasswordHash = hash + } + + upUser, _, err := h.ipc.Database.Admin.UpdateAdminDB(nil, userObjBody, true) + if err != nil { + return nil, err + } + + return upUser, nil +} + +-----END handlers/profile/handlers.go----- + +File: handlers/profile/routes.go +Lines: 36 +-----BEGIN handlers/profile/routes.go----- +package profilehandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "github.com/go-chi/chi/v5" + "net/http" +) + +const ( + profileURI = "/" +) + +type ProfileReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterProfileRoutes регистрирует маршруты для группы profile +func RegisterProfileRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &ProfileReg{ + ipc: ipc, + } + + r.Route("/api/admin/profile", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, profileURI, s.GetProfileHandler) + handlers.RegisterRoute(r, http.MethodPut, profileURI, s.UpdateProfileHandler) + }) + + return nil +} + +-----END handlers/profile/routes.go----- + +File: handlers/register.go +Lines: 162 +-----BEGIN handlers/register.go----- +package handlers + +import ( + "encoding/json" + "errors" + "fmt" + "github.com/go-chi/chi/v5" + "io" + "net/http" + "strconv" +) + +// ErrorResponse структура для возврата ошибок +type ErrorResponse struct { + ErrorCode int `json:"error_code"` + ErrorDescription string `json:"error_description"` +} + +// 🆕 ExcelFileResponse — специальный тип ответа для скачивания файлов +type ExcelFileResponse struct { + Data []byte // Содержимое файла + FileName string // Имя файла для скачивания +} + +// WrapHandlerParams структура для параметров обертки +type WrapHandlerParams struct { + HandlerFunc func(http.ResponseWriter, *http.Request) (interface{}, error) +} + +// responseWriterWrapper предотвращает повторный вызов WriteHeader +type responseWriterWrapper struct { + http.ResponseWriter + wroteHeader bool +} + +func (rw *responseWriterWrapper) WriteHeader(statusCode int) { + if !rw.wroteHeader { + rw.ResponseWriter.WriteHeader(statusCode) + rw.wroteHeader = true + } +} + +func (rw *responseWriterWrapper) Write(b []byte) (int, error) { + if !rw.wroteHeader { + rw.WriteHeader(http.StatusOK) + } + return rw.ResponseWriter.Write(b) +} + +// WrapHandlerF обертка для обработчиков +func WrapHandlerF(p WrapHandlerParams) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + rw := &responseWriterWrapper{ResponseWriter: w} + payload, err := p.HandlerFunc(rw, r) + + // 🆕 Проверяем, не файл ли это + if fileResp, ok := payload.(*ExcelFileResponse); ok && err == nil { + serveExcelFile(rw, fileResp) + return + } + + // Обычный JSON ответ + respondWithJSON(rw, err, payload) + } +} + +// 🆕 serveExcelFile отправляет файл как бинарный ответ +func serveExcelFile(w http.ResponseWriter, fileResp *ExcelFileResponse) { + // Устанавливаем заголовки ДО отправки тела + w.Header().Set("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") + w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, fileResp.FileName)) + w.Header().Set("Content-Length", strconv.Itoa(len(fileResp.Data))) + w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate") + + w.WriteHeader(http.StatusOK) + + // Отправляем содержимое файла + if _, err := w.Write(fileResp.Data); err != nil { + // Логируем ошибку, но заголовки уже отправлены + // Можно добавить логгер здесь + _ = err + } +} + +// RegisterRoute вспомогательная функция для регистрации маршрутов +func RegisterRoute(r chi.Router, method, path string, handlerFunc func(http.ResponseWriter, *http.Request) (interface{}, error)) { + wrappedHandler := WrapHandlerF(WrapHandlerParams{ + HandlerFunc: handlerFunc, + }) + + switch method { + case http.MethodGet: + r.Get(path, wrappedHandler) + case http.MethodPost: + r.Post(path, wrappedHandler) + case http.MethodPatch: + r.Patch(path, wrappedHandler) + case http.MethodPut: + r.Put(path, wrappedHandler) + case http.MethodDelete: + r.Delete(path, wrappedHandler) + } +} + +// ParseRequestBodyPost обрабатывает тело запроса +func ParseRequestBodyPost(r *http.Request, v interface{}) error { + defer r.Body.Close() + + if r.ContentLength == 0 { + return errors.New("body content is empty") + } + + body, err := io.ReadAll(r.Body) + if err != nil { + return err + } + + if err := json.Unmarshal(body, v); err != nil { + return err + } + + return nil +} + +// respondWithJSON отправляет ответ в формате JSON +func respondWithJSON(w http.ResponseWriter, err error, payload interface{}) { + w.Header().Set("Content-Type", "application/json") + + var status int + var response []byte + + if err != nil { + status = http.StatusInternalServerError + errorResponse := ErrorResponse{ + ErrorCode: status, + ErrorDescription: err.Error(), + } + response, _ = json.Marshal(errorResponse) + } else { + response, err = json.Marshal(payload) + if err != nil { + status = http.StatusInternalServerError + errorResponse := ErrorResponse{ + ErrorCode: status, + ErrorDescription: err.Error(), + } + response, _ = json.Marshal(errorResponse) + } else { + status = http.StatusOK + } + } + + if rw, ok := w.(*responseWriterWrapper); ok { + if !rw.wroteHeader { + rw.WriteHeader(status) + } + } else { + w.WriteHeader(status) + } + + _, _ = w.Write(response) +} + +-----END handlers/register.go----- + +File: handlers/roles/handlers.go +Lines: 385 +-----BEGIN handlers/roles/handlers.go----- +package roleshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" +) + +// GetRolesListHandler Получение списка ролей +// @Summary Получение списка ролей +// @Description Получение списка ролей с пагинацией и фильтрацией +// @Tags roles +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/roles [get] +func (s *RolesReg) GetRolesListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + roleParams := &typescore.Role{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, roleParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: roleParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + rolesDbLst, total, errW := s.ipc.Database.Role.GetRolesListDB(ctx, options) + if errW != nil { + return nil, errW + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: rolesDbLst, + }, nil +} + +// GetRoleByIDHandler Получение роли по ID +// @Summary Получение роли по ID +// @Description Получение детальной информации о роли по её ID +// @Tags roles +// @Accept json +// @Produce json +// @Param id path integer true "ID роли" +// @Success 200 {object} typescore.Role "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Роль не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/roles/{id} [get] +func (s *RolesReg) GetRoleByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("role id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid role id") + } + + ctx := r.Context() + role, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, id) + if err != nil { + return nil, err + } + + if role == nil { + return nil, errors.New("role not found") + } + + return role, nil +} + +// CreateRoleHandler Создание роли +// @Summary Создание роли +// @Description Создание новой роли +// @Tags roles +// @Accept json +// @Produce json +// @Param request body typescore.Role true "Данные роли" +// @Success 200 {object} typescore.Role "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/roles [post] +func (s *RolesReg) CreateRoleHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreateRoleHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Role + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.Name == nil || *req.Name == "" { + return nil, errors.New("role name is required") + } + if req.Code == nil || *req.Code == "" { + return nil, errors.New("role code is required") + } + + ctx := r.Context() + existingRoles, _, err := s.ipc.Database.Role.GetRolesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Role{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingRoles) > 0 { + return nil, errors.New("role code already exists") + } + + if req.IsDefault == nil { + v := false + req.IsDefault = &v + } + if req.IsDirector == nil { + v := false + req.IsDirector = &v + } + if req.IsApprover == nil { + v := false + req.IsApprover = &v + } + if req.IsObserver == nil { + v := false + req.IsObserver = &v + } + if req.IsExecutor == nil { + v := false + req.IsExecutor = &v + } + + createdRole, _, err := s.ipc.Database.Role.CreateRoleDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(createdRole.Name), + "code": utilscore.DerefStr(createdRole.Code), + "is_default": utilscore.DerefBool(createdRole.IsDefault), + "is_director": utilscore.DerefBool(createdRole.IsDirector), + "is_approver": utilscore.DerefBool(createdRole.IsApprover), + "is_observer": utilscore.DerefBool(createdRole.IsObserver), + "is_executor": utilscore.DerefBool(createdRole.IsExecutor), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "role", createdRole.ID, + fmt.Sprintf("Создана роль «%s»", utilscore.DerefStr(createdRole.Name)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return createdRole, nil +} + +// UpdateRoleHandler Обновление роли +// @Summary Обновление роли +// @Description Обновление данных существующей роли +// @Tags roles +// @Accept json +// @Produce json +// @Param request body typescore.Role true "Данные роли" +// @Success 200 {object} typescore.Role "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Роль не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/roles [put] +func (s *RolesReg) UpdateRoleHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateRoleHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Role + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("role id is required") + } + + ctx := r.Context() + existingRole, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingRole == nil { + return nil, errors.New("role not found") + } + + if req.Code != nil && *req.Code != "" { + if existingRole.Code == nil || *existingRole.Code != *req.Code { + existingRoles, _, err := s.ipc.Database.Role.GetRolesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Role{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingRoles) > 0 { + return nil, errors.New("role code already exists") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.Name != nil && !utilscore.StrEq(existingRole.Name, req.Name) { + changes = append(changes, fieldChange{"name", utilscore.DerefStr(existingRole.Name), *req.Name}) + summary = append(summary, fmt.Sprintf("название: «%s» → «%s»", utilscore.DerefStr(existingRole.Name), *req.Name)) + } + if req.Code != nil && !utilscore.StrEq(existingRole.Code, req.Code) { + changes = append(changes, fieldChange{"code", utilscore.DerefStr(existingRole.Code), *req.Code}) + summary = append(summary, fmt.Sprintf("код: «%s» → «%s»", utilscore.DerefStr(existingRole.Code), *req.Code)) + } + + boolFields := []struct { + name string + old *bool + new *bool + flag string + }{ + {"is_default", existingRole.IsDefault, req.IsDefault, "по умолчанию"}, + {"is_director", existingRole.IsDirector, req.IsDirector, "директор"}, + {"is_approver", existingRole.IsApprover, req.IsApprover, "согласующий"}, + {"is_observer", existingRole.IsObserver, req.IsObserver, "наблюдатель"}, + {"is_executor", existingRole.IsExecutor, req.IsExecutor, "исполнитель"}, + } + for _, f := range boolFields { + if f.new != nil && !utilscore.BoolEq(f.old, f.new) { + changes = append(changes, fieldChange{f.name, utilscore.DerefBool(f.old), *f.new}) + if *f.new { + summary = append(summary, fmt.Sprintf("включён флаг «%s»", f.flag)) + } else { + summary = append(summary, fmt.Sprintf("выключен флаг «%s»", f.flag)) + } + } + } + + updatedRole, _, err := s.ipc.Database.Role.UpdateRoleDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + description := fmt.Sprintf("Изменена роль «%s»: %s", utilscore.DerefStr(existingRole.Name), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "role", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return updatedRole, nil +} + +// DeleteRoleHandler Удаление роли +// @Summary Удаление роли +// @Description Удаление роли по ID +// @Tags roles +// @Accept json +// @Produce json +// @Param request body typescore.Role true "ID роли для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Роль не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/roles [delete] +func (s *RolesReg) DeleteRoleHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteRoleHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.Role + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("role id is required") + } + + ctx := r.Context() + existingRole, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingRole == nil { + return nil, errors.New("role not found") + } + + if existingRole.IsDefault != nil && *existingRole.IsDefault { + return nil, errors.New("cannot delete default role") + } + + err = s.ipc.Database.Role.DeleteRoleDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(existingRole.Name), + "code": utilscore.DerefStr(existingRole.Code), + "is_director": utilscore.DerefBool(existingRole.IsDirector), + "is_approver": utilscore.DerefBool(existingRole.IsApprover), + "is_observer": utilscore.DerefBool(existingRole.IsObserver), + "is_executor": utilscore.DerefBool(existingRole.IsExecutor), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "role", req.ID, + fmt.Sprintf("Удалена роль «%s»", utilscore.DerefStr(existingRole.Name)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func (s *RolesReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/roles/handlers.go----- + +File: handlers/roles/routes.go +Lines: 39 +-----BEGIN handlers/roles/routes.go----- +package roleshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type RolesReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterRoleRoutes регистрирует маршруты для группы roles +func RegisterRoleRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &RolesReg{ + ipc: ipc, + } + + r.Route("/api/roles", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetRolesListHandler) + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateRoleHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateRoleHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteRoleHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetRoleByIDHandler, + })) + }) + + return nil +} + +-----END handlers/roles/routes.go----- + +File: handlers/system_monitoring/handlers.go +Lines: 259 +-----BEGIN handlers/system_monitoring/handlers.go----- +package monitoringhandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "context" + "net/http" + "os" + "os/exec" + "strconv" + "strings" + "syscall" + "time" + + "github.com/go-chi/chi/v5" +) + +type MonitoringReg struct { + ipc *typesm.InternalProviderControl + // 🆕 ВАЖНО: впишите реальные имена systemd-юнитов ваших сервисов — + // я не знаю точных названий, использовал правдоподобные заглушки. + // Узнать реальные: `systemctl list-units --type=service | grep -i bitrix` + // (или как вы их называли при настройке systemd-юнитов). + monitoredUnits []monitoredUnit +} + +type monitoredUnit struct { + Label string // как показывать в интерфейсе + Unit string // реальное имя systemd-юнита, например "bitrix-bot.service" +} + +func RegisterMonitoringRoutes(r chi.Router, ipc *typesm.InternalProviderControl) error { + s := &MonitoringReg{ + ipc: ipc, + monitoredUnits: []monitoredUnit{ + {Label: "Telegram-бот", Unit: "bitrix-telegram-bot.service"}, + {Label: "Admin REST API", Unit: "bitrix-rest-admin.service"}, + {Label: "nginx", Unit: "nginx.service"}, + {Label: "PostgreSQL", Unit: "postgresql.service"}, + {Label: "Redis", Unit: "redis-server.service"}, + }, + } + + r.Route("/api/monitoring", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetMonitoringStatusHandler) + }) + + return nil +} + +func (s *MonitoringReg) GetMonitoringStatusHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + ctx := r.Context() + + services := make([]map[string]interface{}, 0, len(s.monitoredUnits)) + for _, u := range s.monitoredUnits { + services = append(services, s.checkSystemdUnit(u)) + } + + resources := getHostResources() + + dbHealthy, dbLatencyMs := s.checkDatabase(ctx) + redisHealthy, redisLatencyMs := s.checkRedis(ctx) + + return map[string]interface{}{ + "services": services, + "resources": resources, + "health": map[string]interface{}{ + "database": map[string]interface{}{ + "healthy": dbHealthy, + "latency_ms": dbLatencyMs, + }, + "redis": map[string]interface{}{ + "healthy": redisHealthy, + "latency_ms": redisLatencyMs, + }, + }, + "checked_at": time.Now().Format(time.RFC3339), + }, nil +} + +func (s *MonitoringReg) checkSystemdUnit(u monitoredUnit) map[string]interface{} { + ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) + defer cancel() + + cmd := exec.CommandContext(ctx, "systemctl", "show", u.Unit, + "--property=ActiveState,SubState,ActiveEnterTimestamp", "--value") + output, err := cmd.Output() + + result := map[string]interface{}{ + "label": u.Label, + "unit": u.Unit, + } + + if err != nil { + result["active"] = false + result["state"] = "unknown" + result["error"] = "не удалось получить статус (юнит не найден или нет прав)" + return result + } + + lines := strings.Split(strings.TrimSpace(string(output)), "\n") + activeState := "" + subState := "" + since := "" + if len(lines) >= 1 { + activeState = strings.TrimSpace(lines[0]) + } + if len(lines) >= 2 { + subState = strings.TrimSpace(lines[1]) + } + if len(lines) >= 3 { + since = strings.TrimSpace(lines[2]) + } + + result["active"] = activeState == "active" + result["state"] = activeState + "/" + subState + if since != "" { + result["since"] = since + } + + return result +} + +func getHostResources() map[string]interface{} { + return map[string]interface{}{ + "load_average": getLoadAverage(), + "memory": getMemoryInfo(), + "disk": getDiskInfo("/"), + "uptime_seconds": getUptimeSeconds(), + } +} + +// getLoadAverage — /proc/loadavg: "0.52 0.58 0.59 1/234 5678" +func getLoadAverage() map[string]interface{} { + data, err := readFile("/proc/loadavg") + if err != nil { + return map[string]interface{}{"error": "недоступно"} + } + fields := strings.Fields(data) + if len(fields) < 3 { + return map[string]interface{}{"error": "не удалось разобрать"} + } + l1, _ := strconv.ParseFloat(fields[0], 64) + l5, _ := strconv.ParseFloat(fields[1], 64) + l15, _ := strconv.ParseFloat(fields[2], 64) + return map[string]interface{}{"1m": l1, "5m": l5, "15m": l15} +} + +// getMemoryInfo — /proc/meminfo, ключевые поля в килобайтах у ядра +func getMemoryInfo() map[string]interface{} { + data, err := readFile("/proc/meminfo") + if err != nil { + return map[string]interface{}{"error": "недоступно"} + } + + values := map[string]uint64{} + for _, line := range strings.Split(data, "\n") { + parts := strings.Fields(line) + if len(parts) < 2 { + continue + } + key := strings.TrimSuffix(parts[0], ":") + val, err := strconv.ParseUint(parts[1], 10, 64) + if err != nil { + continue + } + values[key] = val * 1024 // kB -> bytes + } + + total := values["MemTotal"] + available := values["MemAvailable"] + used := uint64(0) + if total > available { + used = total - available + } + + percent := 0.0 + if total > 0 { + percent = float64(used) / float64(total) * 100 + } + + return map[string]interface{}{ + "total_bytes": total, + "used_bytes": used, + "available_bytes": available, + "used_percent": percent, + } +} + +// getDiskInfo — syscall.Statfs по корневой ФС (Linux) +func getDiskInfo(path string) map[string]interface{} { + var stat syscall.Statfs_t + if err := syscall.Statfs(path, &stat); err != nil { + return map[string]interface{}{"error": "недоступно"} + } + + total := stat.Blocks * uint64(stat.Bsize) + free := stat.Bavail * uint64(stat.Bsize) + used := total - free + + percent := 0.0 + if total > 0 { + percent = float64(used) / float64(total) * 100 + } + + return map[string]interface{}{ + "path": path, + "total_bytes": total, + "used_bytes": used, + "free_bytes": free, + "used_percent": percent, + } +} + +func getUptimeSeconds() float64 { + data, err := readFile("/proc/uptime") + if err != nil { + return 0 + } + fields := strings.Fields(data) + if len(fields) < 1 { + return 0 + } + seconds, _ := strconv.ParseFloat(fields[0], 64) + return seconds +} + +func (s *MonitoringReg) checkDatabase(ctx context.Context) (bool, int64) { + start := time.Now() + timeoutCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + + _, _, err := s.ipc.Database.User.GetUsersListDB(timeoutCtx) + latency := time.Since(start).Milliseconds() + + return err == nil, latency +} + +func (s *MonitoringReg) checkRedis(ctx context.Context) (bool, int64) { + start := time.Now() + timeoutCtx, cancel := context.WithTimeout(ctx, 2*time.Second) + defer cancel() + + err := s.ipc.RedisClient.RedisClient.Ping(timeoutCtx) + latency := time.Since(start).Milliseconds() + + return err == nil, latency +} + +func readFile(path string) (string, error) { + data, err := os.ReadFile(path) + if err != nil { + return "", err + } + return string(data), nil +} + +-----END handlers/system_monitoring/handlers.go----- + +File: handlers/topic_categories/handlers.go +Lines: 361 +-----BEGIN handlers/topic_categories/handlers.go----- +package categorieshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" +) + +// GetCategoriesListHandler Получение списка категорий тем +// @Summary Получение списка категорий тем +// @Description Получение списка категорий тем с пагинацией и фильтрацией +// @Tags categories +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param is_active query boolean false "Фильтр по активности" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/categories [get] +func (s *CategoriesReg) GetCategoriesListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + categoryParams := &typescore.ApprovalTopicCategory{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, categoryParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: categoryParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + categoriesDbLst, total, errW := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, options) + if errW != nil { + return nil, errW + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: categoriesDbLst, + }, nil +} + +// GetCategoryByIDHandler Получение категории по ID +// @Summary Получение категории по ID +// @Description Получение детальной информации о категории по её ID +// @Tags categories +// @Accept json +// @Produce json +// @Param id path integer true "ID категории" +// @Success 200 {object} typescore.ApprovalTopicCategory "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Категория не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/categories/{id} [get] +func (s *CategoriesReg) GetCategoryByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("category id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid category id") + } + + ctx := r.Context() + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, id) + if err != nil { + return nil, err + } + + if category == nil { + return nil, errors.New("category not found") + } + + topics, _, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopic{CategoryID: &id}, + }) + if err == nil { + category.Topics = topics + } + + return category, nil +} + +// CreateCategoryHandler Создание категории тем +// @Summary Создание категории тем +// @Description Создание новой категории тем +// @Tags categories +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopicCategory true "Данные категории" +// @Success 200 {object} typescore.ApprovalTopicCategory "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/categories [post] +func (s *CategoriesReg) CreateCategoryHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreateCategoryHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopicCategory + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.Name == nil || *req.Name == "" { + return nil, errors.New("category name is required") + } + if req.Code == nil || *req.Code == "" { + return nil, errors.New("category code is required") + } + + ctx := r.Context() + existingCategories, _, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicCategory{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingCategories) > 0 { + return nil, errors.New("category code already exists") + } + + if req.IsActive == nil { + isActive := true + req.IsActive = &isActive + } + + createdCategory, _, err := s.ipc.Database.ApprovalTopicCategory.CreateApprovalTopicCategoryDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(createdCategory.Name), + "code": utilscore.DerefStr(createdCategory.Code), + "is_active": utilscore.DerefBool(createdCategory.IsActive), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "category", createdCategory.ID, + fmt.Sprintf("Создана категория «%s»", utilscore.DerefStr(createdCategory.Name)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return createdCategory, nil +} + +// UpdateCategoryHandler Обновление категории +// @Summary Обновление категории +// @Description Обновление данных существующей категории +// @Tags categories +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopicCategory true "Данные категории" +// @Success 200 {object} typescore.ApprovalTopicCategory "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Категория не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/categories [put] +func (s *CategoriesReg) UpdateCategoryHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateCategoryHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopicCategory + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("category id is required") + } + + ctx := r.Context() + existingCategory, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingCategory == nil { + return nil, errors.New("category not found") + } + + if req.Code != nil && *req.Code != "" { + if existingCategory.Code == nil || *existingCategory.Code != *req.Code { + existingCategories, _, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicCategory{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingCategories) > 0 { + return nil, errors.New("category code already exists") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.Name != nil && !utilscore.StrEq(existingCategory.Name, req.Name) { + changes = append(changes, fieldChange{"name", utilscore.DerefStr(existingCategory.Name), *req.Name}) + summary = append(summary, fmt.Sprintf("название: «%s» → «%s»", utilscore.DerefStr(existingCategory.Name), *req.Name)) + } + if req.Code != nil && !utilscore.StrEq(existingCategory.Code, req.Code) { + changes = append(changes, fieldChange{"code", utilscore.DerefStr(existingCategory.Code), *req.Code}) + summary = append(summary, fmt.Sprintf("код: «%s» → «%s»", utilscore.DerefStr(existingCategory.Code), *req.Code)) + } + if req.IsActive != nil && !utilscore.BoolEq(existingCategory.IsActive, req.IsActive) { + changes = append(changes, fieldChange{"is_active", utilscore.DerefBool(existingCategory.IsActive), *req.IsActive}) + if *req.IsActive { + summary = append(summary, "активирована") + } else { + summary = append(summary, "деактивирована") + } + } + + updatedCategory, _, err := s.ipc.Database.ApprovalTopicCategory.UpdateApprovalTopicCategoryDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + description := fmt.Sprintf("Изменена категория «%s»: %s", utilscore.DerefStr(existingCategory.Name), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "category", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return updatedCategory, nil +} + +// DeleteCategoryHandler Удаление категории +// @Summary Удаление категории +// @Description Удаление категории по ID +// @Tags categories +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopicCategory true "ID категории для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Категория не найдена" +// @Failure 409 {object} handlers.ErrorResponse "Категория содержит темы" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/categories [delete] +func (s *CategoriesReg) DeleteCategoryHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteCategoryHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopicCategory + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("category id is required") + } + + ctx := r.Context() + existingCategory, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingCategory == nil { + return nil, errors.New("category not found") + } + + topics, _, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopic{CategoryID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(topics) > 0 { + return nil, errors.New("cannot delete category: it contains topics") + } + + err = s.ipc.Database.ApprovalTopicCategory.DeleteApprovalTopicCategoryDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(existingCategory.Name), + "code": utilscore.DerefStr(existingCategory.Code), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "category", req.ID, + fmt.Sprintf("Удалена категория «%s»", utilscore.DerefStr(existingCategory.Name)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func (s *CategoriesReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/topic_categories/handlers.go----- + +File: handlers/topic_categories/routes.go +Lines: 39 +-----BEGIN handlers/topic_categories/routes.go----- +package categorieshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type CategoriesReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterCategoryRoutes регистрирует маршруты для группы categories +func RegisterCategoryRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &CategoriesReg{ + ipc: ipc, + } + + r.Route("/api/categories", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetCategoriesListHandler) + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateCategoryHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateCategoryHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteCategoryHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetCategoryByIDHandler, + })) + }) + + return nil +} + +-----END handlers/topic_categories/routes.go----- + +File: handlers/topic_executors/handlers.go +Lines: 603 +-----BEGIN handlers/topic_executors/handlers.go----- +package topicexecutorshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/go-chi/chi/v5" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" +) + +// GetTopicExecutorsListHandler Получение списка исполнителей тем +// @Summary Получение списка исполнителей тем +// @Description Получение списка исполнителей с пагинацией и фильтрацией +// @Tags topic-executors +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param topic_id query integer false "Фильтр по теме" +// @Param user_id query integer false "Фильтр по пользователю" +// @Param category_id query integer false "Фильтр по категории темы" +// @Param is_active query boolean false "Фильтр по активности" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topic-executors [get] +func (s *TopicExecutorsReg) GetTopicExecutorsListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + executorParams := &typescore.ApprovalTopicExecutor{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, executorParams) + if errW != nil { + return nil, errW + } + + var categoryID *uint64 + if categoryIDStr := queryParams.Get("category_id"); categoryIDStr != "" { + if id, err := strconv.ParseUint(categoryIDStr, 10, 64); err == nil { + categoryID = &id + } + } + + options := typescore.ListDbOptions{ + Filtering: executorParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + + var executorsDbLst []*typescore.ApprovalTopicExecutor + var total uint64 + var err error + + if categoryID != nil { + executorsDbLst, total, err = s.ipc.Database.ApprovalTopicExecutor.GetApprovalTopicExecutorListByCategoryDB(ctx, options, *categoryID) + } else { + executorsDbLst, total, err = s.ipc.Database.ApprovalTopicExecutor.GetApprovalTopicExecutorListDB(ctx, options) + } + + if err != nil { + return nil, err + } + + s.enrichExecutorsBatch(ctx, executorsDbLst) + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: executorsDbLst, + }, nil +} + +// GetExecutorsByTopicIDHandler Получение всех исполнителей для темы +// @Summary Получение исполнителей по теме +// @Description Получение списка всех активных исполнителей для указанной темы, отсортированных по step_order +// @Tags topic-executors +// @Accept json +// @Produce json +// @Param topic_id path integer true "ID темы" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Тема не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topic-executors/by-topic/{topic_id} [get] +func (s *TopicExecutorsReg) GetExecutorsByTopicIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + topicIDStr := chi.URLParam(r, "topic_id") + if topicIDStr == "" { + return nil, errors.New("topic_id is required") + } + + topicID, err := strconv.ParseUint(topicIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid topic_id") + } + + ctx := r.Context() + + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, topicID) + if err != nil { + return nil, err + } + if topic == nil { + return nil, errors.New("topic not found") + } + + executors, err := s.ipc.Database.ApprovalTopicExecutor.GetExecutorsByTopicIDDB(ctx, topicID) + if err != nil { + return nil, err + } + + s.enrichExecutorsBatch(ctx, executors) + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(executors)), + Data: executors, + }, nil +} + +// enrichExecutorsBatch пакетно подгружает темы и пользователей для списка исполнителей +func (s *TopicExecutorsReg) enrichExecutorsBatch(ctx context.Context, executors []*typescore.ApprovalTopicExecutor) { + if len(executors) == 0 { + return + } + + topicIDsSet := make(map[uint64]struct{}) + userIDsSet := make(map[uint64]struct{}) + for _, e := range executors { + if e.TopicID != nil { + topicIDsSet[*e.TopicID] = struct{}{} + } + if e.UserID != nil { + userIDsSet[*e.UserID] = struct{}{} + } + } + + topicIDs := make([]uint64, 0, len(topicIDsSet)) + for id := range topicIDsSet { + topicIDs = append(topicIDs, id) + } + userIDs := make([]uint64, 0, len(userIDsSet)) + for id := range userIDsSet { + userIDs = append(userIDs, id) + } + + topicsMap := make(map[uint64]*typescore.ApprovalTopic) + if topics, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsByIDsDB(ctx, topicIDs); err == nil { + for _, t := range topics { + if t.ID != nil { + topicsMap[*t.ID] = t + } + } + } + + usersMap := make(map[uint64]*typescore.User) + if users, err := s.ipc.Database.User.GetUsersByIDsDB(ctx, userIDs); err == nil { + for _, u := range users { + if u.ID != nil { + usersMap[*u.ID] = u + } + } + } + + for _, e := range executors { + if e.TopicID != nil { + if t, ok := topicsMap[*e.TopicID]; ok { + e.Topic = t + } + } + if e.UserID != nil { + if u, ok := usersMap[*e.UserID]; ok { + e.User = u + } + } + } +} + +// GetTopicExecutorByIDHandler Получение исполнителя по ID +// @Summary Получение исполнителя по ID +// @Description Получение детальной информации об исполнителе по его ID +// @Tags topic-executors +// @Accept json +// @Produce json +// @Param id path integer true "ID исполнителя" +// @Success 200 {object} typescore.ApprovalTopicExecutor "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Исполнитель не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topic-executors/{id} [get] +func (s *TopicExecutorsReg) GetTopicExecutorByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("executor id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid executor id") + } + + ctx := r.Context() + executors, _, err := s.ipc.Database.ApprovalTopicExecutor.GetApprovalTopicExecutorListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicExecutor{ID: &id}, + }) + if err != nil { + return nil, err + } + if len(executors) == 0 { + return nil, errors.New("topic executor not found") + } + + executor := executors[0] + s.enrichExecutor(ctx, executor) + + return executor, nil +} + +// CreateTopicExecutorHandler Создание исполнителя для темы +// @Summary Создание исполнителя +// @Description Назначение исполнителя для конкретной темы согласования +// @Tags topic-executors +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopicExecutor true "Данные исполнителя" +// @Success 200 {object} typescore.ApprovalTopicExecutor "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Тема или пользователь не найдены" +// @Failure 409 {object} handlers.ErrorResponse "Такой исполнитель уже назначен на этот шаг" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topic-executors [post] +func (s *TopicExecutorsReg) CreateTopicExecutorHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreateTopicExecutorHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopicExecutor + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.TopicID == nil { + return nil, errors.New("topic_id is required") + } + if req.UserID == nil { + return nil, errors.New("user_id is required") + } + + ctx := r.Context() + + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.TopicID) + if err != nil { + return nil, err + } + if topic == nil { + return nil, errors.New("topic not found") + } + + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.UserID) + if err != nil { + return nil, err + } + if user == nil { + return nil, errors.New("user not found") + } + + if user.IsBlocked != nil && *user.IsBlocked { + return nil, errors.New("user is blocked") + } + if user.IsFired != nil && *user.IsFired { + return nil, errors.New("user is fired") + } + + stepOrder := 0 + if req.StepOrder != nil { + stepOrder = *req.StepOrder + } + existingExecutors, _, err := s.ipc.Database.ApprovalTopicExecutor.GetApprovalTopicExecutorListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicExecutor{ + TopicID: req.TopicID, + UserID: req.UserID, + StepOrder: &stepOrder, + }, + }) + if err != nil { + return nil, err + } + if len(existingExecutors) > 0 { + return nil, errors.New("this executor is already assigned to this step for the topic") + } + + if req.StepOrder == nil { + defaultStep := 0 + req.StepOrder = &defaultStep + } + if req.RequireFile == nil { + defaultRequire := false + req.RequireFile = &defaultRequire + } + if req.IsActive == nil { + defaultActive := true + req.IsActive = &defaultActive + } + + createdExecutor, _, err := s.ipc.Database.ApprovalTopicExecutor.CreateApprovalTopicExecutorDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichExecutor(ctx, createdExecutor) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "topic_id": *req.TopicID, + "user_id": *req.UserID, + "step_order": utilscore.DerefInt(createdExecutor.StepOrder), + "require_file": utilscore.DerefBool(createdExecutor.RequireFile), + "is_active": utilscore.DerefBool(createdExecutor.IsActive), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "topic_executor", createdExecutor.ID, + fmt.Sprintf("Назначен исполнитель «%s» на тему «%s»", userLabel(createdExecutor.User), topicLabel(createdExecutor.Topic)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return createdExecutor, nil +} + +// UpdateTopicExecutorHandler Обновление исполнителя +// @Summary Обновление исполнителя +// @Description Обновление данных исполнителя для темы +// @Tags topic-executors +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopicExecutor true "Данные исполнителя" +// @Success 200 {object} typescore.ApprovalTopicExecutor "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Исполнитель не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topic-executors [put] +func (s *TopicExecutorsReg) UpdateTopicExecutorHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateTopicExecutorHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopicExecutor + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("executor id is required") + } + + ctx := r.Context() + + existingExecutors, _, err := s.ipc.Database.ApprovalTopicExecutor.GetApprovalTopicExecutorListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicExecutor{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingExecutors) == 0 { + return nil, errors.New("topic executor not found") + } + existing := existingExecutors[0] + s.enrichExecutor(ctx, existing) + + if req.TopicID != nil { + if existing.TopicID == nil || *existing.TopicID != *req.TopicID { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.TopicID) + if err != nil { + return nil, err + } + if topic == nil { + return nil, errors.New("topic not found") + } + } + } + + if req.UserID != nil { + if existing.UserID == nil || *existing.UserID != *req.UserID { + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.UserID) + if err != nil { + return nil, err + } + if user == nil { + return nil, errors.New("user not found") + } + if user.IsBlocked != nil && *user.IsBlocked { + return nil, errors.New("user is blocked") + } + if user.IsFired != nil && *user.IsFired { + return nil, errors.New("user is fired") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.UserID != nil && !utilscore.Uint64Eq(existing.UserID, req.UserID) { + var oldVal interface{} + if existing.UserID != nil { + oldVal = *existing.UserID + } + changes = append(changes, fieldChange{"user_id", oldVal, *req.UserID}) + summary = append(summary, "заменён исполнитель") + } + if req.StepOrder != nil && !utilscore.IntEq(existing.StepOrder, req.StepOrder) { + var oldVal interface{} + if existing.StepOrder != nil { + oldVal = *existing.StepOrder + } + changes = append(changes, fieldChange{"step_order", oldVal, *req.StepOrder}) + summary = append(summary, fmt.Sprintf("порядок шага: %v → %d", oldVal, *req.StepOrder)) + } + if req.RequireFile != nil && !utilscore.BoolEq(existing.RequireFile, req.RequireFile) { + changes = append(changes, fieldChange{"require_file", utilscore.DerefBool(existing.RequireFile), *req.RequireFile}) + if *req.RequireFile { + summary = append(summary, "включено обязательное вложение файла") + } else { + summary = append(summary, "отключено обязательное вложение файла") + } + } + if req.IsActive != nil && !utilscore.BoolEq(existing.IsActive, req.IsActive) { + changes = append(changes, fieldChange{"is_active", utilscore.DerefBool(existing.IsActive), *req.IsActive}) + if *req.IsActive { + summary = append(summary, "активирован") + } else { + summary = append(summary, "деактивирован") + } + } + + updatedExecutor, _, err := s.ipc.Database.ApprovalTopicExecutor.UpdateApprovalTopicExecutorDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + s.enrichExecutor(ctx, updatedExecutor) + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + description := fmt.Sprintf("Изменён исполнитель темы «%s»: %s", topicLabel(existing.Topic), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "topic_executor", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return updatedExecutor, nil +} + +// DeleteTopicExecutorHandler Удаление исполнителя +// @Summary Удаление исполнителя +// @Description Удаление исполнителя из темы по ID +// @Tags topic-executors +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopicExecutor true "ID записи для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Запись не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topic-executors [delete] +func (s *TopicExecutorsReg) DeleteTopicExecutorHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteTopicExecutorHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopicExecutor + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("executor id is required") + } + + ctx := r.Context() + + existingExecutors, _, err := s.ipc.Database.ApprovalTopicExecutor.GetApprovalTopicExecutorListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopicExecutor{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingExecutors) == 0 { + return nil, errors.New("topic executor not found") + } + existing := existingExecutors[0] + s.enrichExecutor(ctx, existing) + + err = s.ipc.Database.ApprovalTopicExecutor.DeleteApprovalTopicExecutorDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "step_order": utilscore.DerefInt(existing.StepOrder), + "require_file": utilscore.DerefBool(existing.RequireFile), + } + if existing.TopicID != nil { + snapshot["topic_id"] = *existing.TopicID + } + if existing.UserID != nil { + snapshot["user_id"] = *existing.UserID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "topic_executor", req.ID, + fmt.Sprintf("Снят исполнитель «%s» с темы «%s»", userLabel(existing.User), topicLabel(existing.Topic)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +// enrichExecutor подгружает связанные данные для записи исполнителя +func (s *TopicExecutorsReg) enrichExecutor(ctx context.Context, exec *typescore.ApprovalTopicExecutor) { + if exec == nil { + return + } + + if exec.TopicID != nil { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *exec.TopicID) + if err == nil && topic != nil { + exec.Topic = topic + } + } + + if exec.UserID != nil { + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, *exec.UserID) + if err == nil && user != nil { + exec.User = user + } + } +} + +func topicLabel(topic *typescore.ApprovalTopic) string { + if topic == nil || topic.Name == nil { + return "—" + } + return *topic.Name +} + +func userLabel(user *typescore.User) string { + if user == nil || user.FullName == nil { + return "—" + } + return *user.FullName +} + +func (s *TopicExecutorsReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/topic_executors/handlers.go----- + +File: handlers/topic_executors/routes.go +Lines: 43 +-----BEGIN handlers/topic_executors/routes.go----- +package topicexecutorshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type TopicExecutorsReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterTopicExecutorRoutes регистрирует маршруты для группы topic-executors +func RegisterTopicExecutorRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &TopicExecutorsReg{ + ipc: ipc, + } + + r.Route("/api/topic-executors", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetTopicExecutorsListHandler) + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateTopicExecutorHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateTopicExecutorHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteTopicExecutorHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetTopicExecutorByIDHandler, + })) + + r.Get("/by-topic/{topic_id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetExecutorsByTopicIDHandler, + })) + }) + + return nil +} + +-----END handlers/topic_executors/routes.go----- + +File: handlers/topics/handlers.go +Lines: 519 +-----BEGIN handlers/topics/handlers.go----- +package topicshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" +) + +// GetTopicsListHandler Получение списка тем +// @Summary Получение списка тем +// @Description Получение списка тем с пагинацией и фильтрацией +// @Tags topics +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param category_id query integer false "Фильтр по категории" +// @Param is_active query boolean false "Фильтр по активности" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topics [get] +func (s *TopicsReg) GetTopicsListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + topicParams := &typescore.ApprovalTopic{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, topicParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: topicParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + topicsDbLst, total, errW := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, options) + if errW != nil { + return nil, errW + } + + categoryIDsSet := make(map[uint64]struct{}) + for _, topic := range topicsDbLst { + if topic.CategoryID != nil { + categoryIDsSet[*topic.CategoryID] = struct{}{} + } + } + categoryIDs := make([]uint64, 0, len(categoryIDsSet)) + for id := range categoryIDsSet { + categoryIDs = append(categoryIDs, id) + } + + categoriesMap := make(map[uint64]*typescore.ApprovalTopicCategory) + if categories, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoriesByIDsDB(ctx, categoryIDs); err == nil { + for _, c := range categories { + if c.ID != nil { + categoriesMap[*c.ID] = c + } + } + } + + for _, topic := range topicsDbLst { + if topic.CategoryID != nil { + if cat, ok := categoriesMap[*topic.CategoryID]; ok { + topic.Category = cat + } + } + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: topicsDbLst, + }, nil +} + +// GetTopicByIDHandler Получение темы по ID +// @Summary Получение темы по ID +// @Description Получение детальной информации о теме по её ID +// @Tags topics +// @Accept json +// @Produce json +// @Param id path integer true "ID темы" +// @Success 200 {object} typescore.ApprovalTopic "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Тема не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topics/{id} [get] +func (s *TopicsReg) GetTopicByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("topic id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid topic id") + } + + ctx := r.Context() + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, id) + if err != nil { + return nil, err + } + + if topic == nil { + return nil, errors.New("topic not found") + } + + if topic.CategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *topic.CategoryID) + if err == nil && category != nil { + topic.Category = category + } + } + + return topic, nil +} + +// CreateTopicHandler Создание темы +// @Summary Создание темы +// @Description Создание новой темы согласования +// @Tags topics +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopic true "Данные темы" +// @Success 200 {object} typescore.ApprovalTopic "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topics [post] +func (s *TopicsReg) CreateTopicHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreateTopicHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopic + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.Name == nil || *req.Name == "" { + return nil, errors.New("topic name is required") + } + if req.Code == nil || *req.Code == "" { + return nil, errors.New("topic code is required") + } + if req.CategoryID == nil { + return nil, errors.New("category_id is required") + } + + ctx := r.Context() + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.CategoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("category not found") + } + + existingTopics, _, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopic{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingTopics) > 0 { + return nil, errors.New("topic code already exists") + } + + if req.IsActive == nil { + isActive := true + req.IsActive = &isActive + } + if req.ApprovalMode == nil { + mode := "sequential" + req.ApprovalMode = &mode + } + if req.AllowsFile == nil { + v := false + req.AllowsFile = &v + } + if req.AllowApproverSelection == nil { + v := false + req.AllowApproverSelection = &v + } + if req.AllowObserverSelection == nil { + v := false + req.AllowObserverSelection = &v + } + if req.RequireApproverComment == nil { + v := false + req.RequireApproverComment = &v + } + if req.RequiresFile == nil { + v := false + req.RequiresFile = &v + } + if req.RequireObserverSelection == nil { + v := false + req.RequireObserverSelection = &v + } + + createdTopic, _, err := s.ipc.Database.ApprovalTopic.CreateApprovalTopicDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if createdTopic.CategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *createdTopic.CategoryID) + if err == nil && category != nil { + createdTopic.Category = category + } + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(createdTopic.Name), + "code": utilscore.DerefStr(createdTopic.Code), + "category_id": *req.CategoryID, + "approval_mode": utilscore.DerefStr(createdTopic.ApprovalMode), + "allows_file": utilscore.DerefBool(createdTopic.AllowsFile), + "requires_file": utilscore.DerefBool(createdTopic.RequiresFile), + "allow_approver_selection": utilscore.DerefBool(createdTopic.AllowApproverSelection), + "allow_observer_selection": utilscore.DerefBool(createdTopic.AllowObserverSelection), + "require_observer_selection": utilscore.DerefBool(createdTopic.RequireObserverSelection), + "require_approver_comment": utilscore.DerefBool(createdTopic.RequireApproverComment), + "is_active": utilscore.DerefBool(createdTopic.IsActive), + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "topic", createdTopic.ID, + fmt.Sprintf("Создана тема «%s» (%s)", utilscore.DerefStr(createdTopic.Name), categoryLabel(createdTopic.Category)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return createdTopic, nil +} + +// UpdateTopicHandler Обновление темы +// @Summary Обновление темы +// @Description Обновление данных существующей темы +// @Tags topics +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopic true "Данные темы" +// @Success 200 {object} typescore.ApprovalTopic "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Тема не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topics [put] +func (s *TopicsReg) UpdateTopicHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateTopicHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopic + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("topic id is required") + } + + ctx := r.Context() + existingTopic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingTopic == nil { + return nil, errors.New("topic not found") + } + + if req.CategoryID != nil { + if existingTopic.CategoryID == nil || *existingTopic.CategoryID != *req.CategoryID { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.CategoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("category not found") + } + } + } + + if req.Code != nil && *req.Code != "" { + if existingTopic.Code == nil || *existingTopic.Code != *req.Code { + existingTopics, _, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.ApprovalTopic{Code: req.Code}, + }) + if err != nil { + return nil, err + } + if len(existingTopics) > 0 { + return nil, errors.New("topic code already exists") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + strFields := []struct { + name string + old *string + new *string + label string + }{ + {"name", existingTopic.Name, req.Name, "название"}, + {"code", existingTopic.Code, req.Code, "код"}, + {"approval_mode", existingTopic.ApprovalMode, req.ApprovalMode, "режим согласования"}, + {"duration_type", existingTopic.DurationType, req.DurationType, "тип длительности"}, + {"time_type", existingTopic.TimeType, req.TimeType, "тип времени"}, + {"payment_type", existingTopic.PaymentType, req.PaymentType, "тип оплаты"}, + {"first_approver_role_code", existingTopic.FirstApproverRoleCode, req.FirstApproverRoleCode, "роль первого согласующего"}, + } + for _, f := range strFields { + if f.new != nil && !utilscore.StrEq(f.old, f.new) { + changes = append(changes, fieldChange{f.name, utilscore.DerefStr(f.old), *f.new}) + summary = append(summary, fmt.Sprintf("%s: «%s» → «%s»", f.label, utilscore.DerefStr(f.old), *f.new)) + } + } + + boolFields := []struct { + name string + old *bool + new *bool + label string + }{ + {"is_active", existingTopic.IsActive, req.IsActive, "активна"}, + {"allows_file", existingTopic.AllowsFile, req.AllowsFile, "разрешён файл"}, + {"requires_file", existingTopic.RequiresFile, req.RequiresFile, "обязателен файл"}, + {"allow_approver_selection", existingTopic.AllowApproverSelection, req.AllowApproverSelection, "выбор согласующего"}, + {"allow_observer_selection", existingTopic.AllowObserverSelection, req.AllowObserverSelection, "выбор наблюдателя"}, + {"require_observer_selection", existingTopic.RequireObserverSelection, req.RequireObserverSelection, "наблюдатель обязателен"}, + {"require_approver_comment", existingTopic.RequireApproverComment, req.RequireApproverComment, "комментарий обязателен"}, + {"allow_delegation_selection", existingTopic.AllowDelegationSelection, req.AllowDelegationSelection, "делегирование обязанностей"}, + } + for _, f := range boolFields { + if f.new != nil && !utilscore.BoolEq(f.old, f.new) { + changes = append(changes, fieldChange{f.name, utilscore.DerefBool(f.old), *f.new}) + if *f.new { + summary = append(summary, fmt.Sprintf("включено «%s»", f.label)) + } else { + summary = append(summary, fmt.Sprintf("выключено «%s»", f.label)) + } + } + } + + if req.CategoryID != nil && !utilscore.Uint64Eq(existingTopic.CategoryID, req.CategoryID) { + var oldVal interface{} + if existingTopic.CategoryID != nil { + oldVal = *existingTopic.CategoryID + } + changes = append(changes, fieldChange{"category_id", oldVal, *req.CategoryID}) + summary = append(summary, "изменена категория") + } + + updatedTopic, _, err := s.ipc.Database.ApprovalTopic.UpdateApprovalTopicDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if updatedTopic.CategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *updatedTopic.CategoryID) + if err == nil && category != nil { + updatedTopic.Category = category + } + } + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + description := fmt.Sprintf("Изменена тема «%s»: %s", utilscore.DerefStr(existingTopic.Name), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "topic", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return updatedTopic, nil +} + +// DeleteTopicHandler Удаление темы +// @Summary Удаление темы +// @Description Удаление темы по ID +// @Tags topics +// @Accept json +// @Produce json +// @Param request body typescore.ApprovalTopic true "ID темы для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Тема не найдена" +// @Failure 409 {object} handlers.ErrorResponse "Тема содержит заявки" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/topics [delete] +func (s *TopicsReg) DeleteTopicHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteTopicHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.ApprovalTopic + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("topic id is required") + } + + ctx := r.Context() + existingTopic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingTopic == nil { + return nil, errors.New("topic not found") + } + + approvals, _, err := s.ipc.Database.Approval.GetApprovalsListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.Approval{TopicID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(approvals) > 0 { + return nil, errors.New("cannot delete topic: it has existing approvals") + } + + if existingTopic.CategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *existingTopic.CategoryID) + if err == nil && category != nil { + existingTopic.Category = category + } + } + + err = s.ipc.Database.ApprovalTopic.DeleteApprovalTopicDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "name": utilscore.DerefStr(existingTopic.Name), + "code": utilscore.DerefStr(existingTopic.Code), + } + if existingTopic.CategoryID != nil { + snapshot["category_id"] = *existingTopic.CategoryID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "topic", req.ID, + fmt.Sprintf("Удалена тема «%s» (%s)", utilscore.DerefStr(existingTopic.Name), categoryLabel(existingTopic.Category)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func categoryLabel(category *typescore.ApprovalTopicCategory) string { + if category == nil || category.Name == nil { + return "—" + } + return *category.Name +} + +func (s *TopicsReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/topics/handlers.go----- + +File: handlers/topics/routes.go +Lines: 39 +-----BEGIN handlers/topics/routes.go----- +package topicshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type TopicsReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterTopicRoutes регистрирует маршруты для группы topics +func RegisterTopicRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &TopicsReg{ + ipc: ipc, + } + + r.Route("/api/topics", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetTopicsListHandler) + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateTopicHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateTopicHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteTopicHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetTopicByIDHandler, + })) + }) + + return nil +} + +-----END handlers/topics/routes.go----- + +File: handlers/user_hierarchy/handlers.go +Lines: 531 +-----BEGIN handlers/user_hierarchy/handlers.go----- +package hierarchieshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" +) + +// GetHierarchiesListHandler Получение списка записей иерархии +// @Summary Получение списка записей иерархии +// @Description Получение списка связей подчинённый-согласующий с пагинацией и фильтрацией +// @Tags hierarchies +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param subordinate_id query integer false "Фильтр по подчинённому" +// @Param approver_id query integer false "Фильтр по согласующему" +// @Param department_id query integer false "Фильтр по отделу" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/hierarchies [get] +func (s *HierarchiesReg) GetHierarchiesListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + hierarchyParams := &typescore.UserHierarchy{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, hierarchyParams) + if errW != nil { + return nil, errW + } + + options := typescore.ListDbOptions{ + Filtering: hierarchyParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + hierarchiesDbLst, total, errW := s.ipc.Database.UserHierarchy.GetHierarchiesWithRelations(ctx, options) + if errW != nil { + return nil, errW + } + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: hierarchiesDbLst, + }, nil +} + +// GetHierarchyByIDHandler Получение записи иерархии по ID +// @Summary Получение записи иерархии по ID +// @Description Получение детальной информации о записи иерархии по её ID +// @Tags hierarchies +// @Accept json +// @Produce json +// @Param id path integer true "ID записи" +// @Success 200 {object} typescore.UserHierarchy "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Запись не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/hierarchies/{id} [get] +func (s *HierarchiesReg) GetHierarchyByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("hierarchy id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid hierarchy id") + } + + ctx := r.Context() + hierarchies, _, err := s.ipc.Database.UserHierarchy.GetHierarchiesWithRelations(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserHierarchy{ID: &id}, + }) + if err != nil { + return nil, err + } + if len(hierarchies) == 0 { + return nil, errors.New("hierarchy not found") + } + + hierarchy := hierarchies[0] + return hierarchy, nil +} + +// CreateHierarchyHandler Создание записи иерархии +// @Summary Создание записи иерархии +// @Description Создание новой связи подчинённый-согласующий +// @Tags hierarchies +// @Accept json +// @Produce json +// @Param request body typescore.UserHierarchy true "Данные иерархии" +// @Success 200 {object} typescore.UserHierarchy "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 409 {object} handlers.ErrorResponse "Такая связь уже существует" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/hierarchies [post] +func (s *HierarchiesReg) CreateHierarchyHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 CreateHierarchyHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.UserHierarchy + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.SubordinateID == nil { + return nil, errors.New("subordinate_id is required") + } + if req.ApproverID == nil { + return nil, errors.New("approver_id is required") + } + if req.DepartmentID == nil { + return nil, errors.New("department_id is required") + } + + ctx := r.Context() + + subordinate, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.SubordinateID) + if err != nil { + return nil, err + } + if subordinate == nil { + return nil, errors.New("subordinate user not found") + } + + approver, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.ApproverID) + if err != nil { + return nil, err + } + if approver == nil { + return nil, errors.New("approver user not found") + } + + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *req.DepartmentID) + if err != nil { + return nil, err + } + if department == nil { + return nil, errors.New("department not found") + } + + if req.TopicCategoryID != nil { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.TopicCategoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("topic category not found") + } + } + + if req.TopicID != nil { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.TopicID) + if err != nil { + return nil, err + } + if topic == nil { + return nil, errors.New("topic not found") + } + + if req.TopicCategoryID != nil && topic.CategoryID != nil { + if *topic.CategoryID != *req.TopicCategoryID { + return nil, errors.New("topic does not belong to the specified category") + } + } + } + + existingHierarchies, _, err := s.ipc.Database.UserHierarchy.GetUserHierarchyListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserHierarchy{ + SubordinateID: req.SubordinateID, + ApproverID: req.ApproverID, + DepartmentID: req.DepartmentID, + TopicID: req.TopicID, + TopicCategoryID: req.TopicCategoryID, + TargetSystem: req.TargetSystem, + }, + }) + if err != nil { + return nil, err + } + if len(existingHierarchies) > 0 { + return nil, errors.New("this hierarchy relation already exists") + } + + if req.Priority == nil { + defaultPriority := 1 + req.Priority = &defaultPriority + } + + createdHierarchy, _, err := s.ipc.Database.UserHierarchy.CreateUserHierarchyDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "subordinate_id": *req.SubordinateID, + "approver_id": *req.ApproverID, + "department_id": *req.DepartmentID, + "priority": *req.Priority, + } + if req.TopicID != nil { + snapshot["topic_id"] = *req.TopicID + } + if req.TopicCategoryID != nil { + snapshot["topic_category_id"] = *req.TopicCategoryID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "hierarchy", createdHierarchy.ID, + fmt.Sprintf("Создана связь: «%s» → согласующий «%s» (%s)", userLabel(subordinate), userLabel(approver), utilscore.DerefStr(department.Name)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return createdHierarchy, nil +} + +// UpdateHierarchyHandler Обновление записи иерархии +// @Summary Обновление записи иерархии +// @Description Обновление данных существующей записи иерархии +// @Tags hierarchies +// @Accept json +// @Produce json +// @Param request body typescore.UserHierarchy true "Данные иерархии" +// @Success 200 {object} typescore.UserHierarchy "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Запись не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/hierarchies [put] +func (s *HierarchiesReg) UpdateHierarchyHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateHierarchyHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.UserHierarchy + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("hierarchy id is required") + } + + ctx := r.Context() + + existingHierarchies, _, err := s.ipc.Database.UserHierarchy.GetHierarchiesWithRelations(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserHierarchy{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingHierarchies) == 0 { + return nil, errors.New("hierarchy not found") + } + existing := existingHierarchies[0] + + if req.SubordinateID != nil { + if existing.SubordinateID == nil || *existing.SubordinateID != *req.SubordinateID { + subordinate, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.SubordinateID) + if err != nil { + return nil, err + } + if subordinate == nil { + return nil, errors.New("subordinate user not found") + } + } + } + + if req.ApproverID != nil { + if existing.ApproverID == nil || *existing.ApproverID != *req.ApproverID { + approver, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.ApproverID) + if err != nil { + return nil, err + } + if approver == nil { + return nil, errors.New("approver user not found") + } + } + } + + if req.DepartmentID != nil { + if existing.DepartmentID == nil || *existing.DepartmentID != *req.DepartmentID { + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *req.DepartmentID) + if err != nil { + return nil, err + } + if department == nil { + return nil, errors.New("department not found") + } + } + } + + if req.TopicCategoryID != nil { + if existing.TopicCategoryID == nil || *existing.TopicCategoryID != *req.TopicCategoryID { + category, err := s.ipc.Database.ApprovalTopicCategory.GetApprovalTopicCategoryByIDDB(ctx, *req.TopicCategoryID) + if err != nil { + return nil, err + } + if category == nil { + return nil, errors.New("topic category not found") + } + } + } + + if req.TopicID != nil { + if existing.TopicID == nil || *existing.TopicID != *req.TopicID { + topic, err := s.ipc.Database.ApprovalTopic.GetApprovalTopicByIDDB(ctx, *req.TopicID) + if err != nil { + return nil, err + } + if topic == nil { + return nil, errors.New("topic not found") + } + + categoryIDToCheck := req.TopicCategoryID + if categoryIDToCheck == nil { + categoryIDToCheck = existing.TopicCategoryID + } + if categoryIDToCheck != nil && topic.CategoryID != nil && *topic.CategoryID != *categoryIDToCheck { + return nil, errors.New("topic does not belong to the specified category") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.SubordinateID != nil && !utilscore.Uint64Eq(existing.SubordinateID, req.SubordinateID) { + var oldVal interface{} + if existing.SubordinateID != nil { + oldVal = *existing.SubordinateID + } + changes = append(changes, fieldChange{"subordinate_id", oldVal, *req.SubordinateID}) + summary = append(summary, "изменён подчинённый") + } + if req.ApproverID != nil && !utilscore.Uint64Eq(existing.ApproverID, req.ApproverID) { + var oldVal interface{} + if existing.ApproverID != nil { + oldVal = *existing.ApproverID + } + changes = append(changes, fieldChange{"approver_id", oldVal, *req.ApproverID}) + summary = append(summary, "изменён согласующий") + } + if req.DepartmentID != nil && !utilscore.Uint64Eq(existing.DepartmentID, req.DepartmentID) { + var oldVal interface{} + if existing.DepartmentID != nil { + oldVal = *existing.DepartmentID + } + changes = append(changes, fieldChange{"department_id", oldVal, *req.DepartmentID}) + summary = append(summary, "изменён отдел") + } + if req.TopicID != nil && !utilscore.Uint64Eq(existing.TopicID, req.TopicID) { + var oldVal interface{} + if existing.TopicID != nil { + oldVal = *existing.TopicID + } + changes = append(changes, fieldChange{"topic_id", oldVal, *req.TopicID}) + summary = append(summary, "изменена тема") + } + if req.TopicCategoryID != nil && !utilscore.Uint64Eq(existing.TopicCategoryID, req.TopicCategoryID) { + var oldVal interface{} + if existing.TopicCategoryID != nil { + oldVal = *existing.TopicCategoryID + } + changes = append(changes, fieldChange{"topic_category_id", oldVal, *req.TopicCategoryID}) + summary = append(summary, "изменена категория") + } + if req.Priority != nil && !utilscore.IntEq(existing.Priority, req.Priority) { + var oldVal interface{} + if existing.Priority != nil { + oldVal = *existing.Priority + } + changes = append(changes, fieldChange{"priority", oldVal, *req.Priority}) + summary = append(summary, fmt.Sprintf("приоритет: %v → %d", oldVal, *req.Priority)) + } + + updatedHierarchy, _, err := s.ipc.Database.UserHierarchy.UpdateUserHierarchyDB(ctx, nil, &req, true) + if err != nil { + return nil, err + } + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + description := fmt.Sprintf("Изменена связь «%s» → «%s»: %s", userLabel(existing.Subordinate), userLabel(existing.Approver), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "hierarchy", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return updatedHierarchy, nil +} + +// DeleteHierarchyHandler Удаление записи иерархии +// @Summary Удаление записи иерархии +// @Description Удаление связи подчинённый-согласующий по ID +// @Tags hierarchies +// @Accept json +// @Produce json +// @Param request body typescore.UserHierarchy true "ID записи для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Запись не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/hierarchies [delete] +func (s *HierarchiesReg) DeleteHierarchyHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 DeleteHierarchyHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.UserHierarchy + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("hierarchy id is required") + } + + ctx := r.Context() + + existingHierarchies, _, err := s.ipc.Database.UserHierarchy.GetHierarchiesWithRelations(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserHierarchy{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingHierarchies) == 0 { + return nil, errors.New("hierarchy not found") + } + existing := existingHierarchies[0] + + err = s.ipc.Database.UserHierarchy.DeleteUserHierarchyDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "priority": utilscore.DerefInt(existing.Priority), + } + if existing.SubordinateID != nil { + snapshot["subordinate_id"] = *existing.SubordinateID + } + if existing.ApproverID != nil { + snapshot["approver_id"] = *existing.ApproverID + } + if existing.DepartmentID != nil { + snapshot["department_id"] = *existing.DepartmentID + } + if existing.TopicID != nil { + snapshot["topic_id"] = *existing.TopicID + } + if existing.TopicCategoryID != nil { + snapshot["topic_category_id"] = *existing.TopicCategoryID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "hierarchy", req.ID, + fmt.Sprintf("Удалена связь: «%s» → согласующий «%s»", userLabel(existing.Subordinate), userLabel(existing.Approver)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func userLabel(user *typescore.User) string { + if user == nil || user.FullName == nil { + return "—" + } + return *user.FullName +} + +func (s *HierarchiesReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/user_hierarchy/handlers.go----- + +File: handlers/user_hierarchy/routes.go +Lines: 39 +-----BEGIN handlers/user_hierarchy/routes.go----- +package hierarchieshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type HierarchiesReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterHierarchyRoutes регистрирует маршруты для группы hierarchies +func RegisterHierarchyRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &HierarchiesReg{ + ipc: ipc, + } + + r.Route("/api/hierarchies", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetHierarchiesListHandler) + handlers.RegisterRoute(r, http.MethodPost, "/", s.CreateHierarchyHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateHierarchyHandler) + handlers.RegisterRoute(r, http.MethodDelete, "/", s.DeleteHierarchyHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetHierarchyByIDHandler, + })) + }) + + return nil +} + +-----END handlers/user_hierarchy/routes.go----- + +File: handlers/user_roles/handlers.go +Lines: 477 +-----BEGIN handlers/user_roles/handlers.go----- +package userroleshandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" +) + +// AssignUserRoleRequest — запрос на назначение роли пользователю +type AssignUserRoleRequest struct { + UserID *uint64 `json:"user_id"` + RoleID *uint64 `json:"role_id"` +} + +// BulkAssignRolesRequest — запрос на массовое назначение ролей +type BulkAssignRolesRequest struct { + UserID *uint64 `json:"user_id"` + RoleIDs []*uint64 `json:"role_ids"` +} + +// GetUserRolesListHandler Получение списка ролей пользователя +// @Summary Получение списка ролей пользователя +// @Description Получение списка ролей, назначенных конкретному пользователю +// @Tags user-roles +// @Accept json +// @Produce json +// @Param user_id query integer true "ID пользователя" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/user-roles [get] +func (s *UserRolesReg) GetUserRolesListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + roleParams := &typescore.UserRole{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, roleParams) + if errW != nil { + return nil, errW + } + + if roleParams.UserID == nil { + return nil, errors.New("user_id is required") + } + + options := typescore.ListDbOptions{ + Filtering: roleParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + userRolesDbLst, total, errW := s.ipc.Database.UserRole.GetUserRolesListDB(ctx, options) + if errW != nil { + return nil, errW + } + + s.enrichUserRolesBatch(ctx, userRolesDbLst) + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: userRolesDbLst, + }, nil +} + +// GetUserRolesByUserIDHandler Получение списка ролей пользователя по ID из URL +// @Summary Получение списка ролей пользователя по ID +// @Description Получение списка ролей, назначенных пользователю с указанным ID +// @Tags user-roles +// @Accept json +// @Produce json +// @Param user_id path integer true "ID пользователя" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Пользователь не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/users/{user_id}/roles [get] +func (s *UserRolesReg) GetUserRolesByUserIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + userIDStr := chi.URLParam(r, "user_id") + if userIDStr == "" { + return nil, errors.New("user_id is required") + } + + userID, err := strconv.ParseUint(userIDStr, 10, 64) + if err != nil { + return nil, errors.New("invalid user_id") + } + + ctx := r.Context() + + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, userID) + if err != nil { + return nil, err + } + if user == nil { + return nil, errors.New("user not found") + } + + userRolesDbLst, _, errW := s.ipc.Database.UserRole.GetUserRolesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserRole{UserID: &userID}, + }) + if errW != nil { + return nil, errW + } + + s.enrichUserRolesBatch(ctx, userRolesDbLst) + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(userRolesDbLst)), + Data: userRolesDbLst, + }, nil +} + +// enrichUserRolesBatch пакетно подгружает роли для списка user_role +func (s *UserRolesReg) enrichUserRolesBatch(ctx context.Context, userRoles []*typescore.UserRole) { + if len(userRoles) == 0 { + return + } + + roleIDsSet := make(map[uint64]struct{}) + for _, ur := range userRoles { + if ur.RoleID != nil { + roleIDsSet[*ur.RoleID] = struct{}{} + } + } + + roleIDs := make([]uint64, 0, len(roleIDsSet)) + for id := range roleIDsSet { + roleIDs = append(roleIDs, id) + } + + rolesMap := make(map[uint64]*typescore.Role) + if roles, err := s.ipc.Database.Role.GetRolesByIDsDB(ctx, roleIDs); err == nil { + for _, role := range roles { + if role.ID != nil { + rolesMap[*role.ID] = role + } + } + } + + for _, ur := range userRoles { + if ur.RoleID != nil { + if role, ok := rolesMap[*ur.RoleID]; ok { + ur.Role = role + } + } + } +} + +// BulkAssignRolesHandler Массовое назначение ролей пользователю +// @Summary Массовое назначение ролей +// @Description Полная замена ролей пользователя: удаляет все текущие роли и назначает новые +// @Tags user-roles +// @Accept json +// @Produce json +// @Param request body BulkAssignRolesRequest true "user_id и список role_ids" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Пользователь не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/user-roles/bulk [post] +func (s *UserRolesReg) BulkAssignRolesHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 BulkAssignRolesHandler: ReadAll error:", err) + return nil, err + } + + var req BulkAssignRolesRequest + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.UserID == nil { + return nil, errors.New("user_id is required") + } + + ctx := r.Context() + + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.UserID) + if err != nil { + return nil, err + } + if user == nil { + return nil, errors.New("user not found") + } + + roleIDsSet := make(map[uint64]struct{}) + roleIDs := make([]uint64, 0, len(req.RoleIDs)) + for _, roleID := range req.RoleIDs { + if roleID == nil { + continue + } + if _, exists := roleIDsSet[*roleID]; exists { + continue + } + roleIDsSet[*roleID] = struct{}{} + roleIDs = append(roleIDs, *roleID) + } + + if len(roleIDs) > 0 { + existingRoles, err := s.ipc.Database.Role.GetRolesByIDsDB(ctx, roleIDs) + if err != nil { + return nil, err + } + foundIDs := make(map[uint64]struct{}, len(existingRoles)) + for _, role := range existingRoles { + if role.ID != nil { + foundIDs[*role.ID] = struct{}{} + } + } + for _, roleID := range roleIDs { + if _, ok := foundIDs[roleID]; !ok { + return nil, errors.New("role not found: " + strconv.FormatUint(roleID, 10)) + } + } + } + + // снимаем "было" до удаления — иначе после DeleteUserRolesByUserIDDB это уже не достать + previousRoles, _, _ := s.ipc.Database.UserRole.GetUserRolesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserRole{UserID: req.UserID}, + }) + s.enrichUserRolesBatch(ctx, previousRoles) + + if err := s.ipc.Database.UserRole.DeleteUserRolesByUserIDDB(ctx, *req.UserID); err != nil { + logrus.Errorf("BulkAssignRolesHandler: failed to delete user_roles for user_id=%d: %v", *req.UserID, err) + return nil, err + } + + createdRoles, err := s.ipc.Database.UserRole.CreateUserRolesBulkDB(ctx, nil, *req.UserID, roleIDs) + if err != nil { + logrus.Errorf("BulkAssignRolesHandler: failed to bulk create user_roles: %v", err) + return nil, err + } + + s.enrichUserRolesBatch(ctx, createdRoles) + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + oldNames := roleNames(previousRoles) + newNames := roleNames(createdRoles) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "user_roles", req.UserID, + fmt.Sprintf("Заменены роли «%s»: [%s] → [%s]", userLabel(user), strings.Join(oldNames, ", "), strings.Join(newNames, ", ")), + map[string]interface{}{ + "user_id": *req.UserID, + "roles_before": oldNames, + "roles_after": newNames, + }, + ) + } + + return &typescore.ApiResponseBase{ + TotalCount: uint64(len(createdRoles)), + Data: createdRoles, + }, nil +} + +// AssignUserRoleHandler Назначение роли пользователю +// @Summary Назначение роли пользователю +// @Description Назначение роли пользователю (создание связи user_id + role_id) +// @Tags user-roles +// @Accept json +// @Produce json +// @Param request body AssignUserRoleRequest true "user_id и role_id" +// @Success 200 {object} typescore.UserRole "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Пользователь или роль не найдены" +// @Failure 409 {object} handlers.ErrorResponse "Роль уже назначена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/user-roles [post] +func (s *UserRolesReg) AssignUserRoleHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 AssignUserRoleHandler: ReadAll error:", err) + return nil, err + } + + var req AssignUserRoleRequest + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.UserID == nil { + return nil, errors.New("user_id is required") + } + if req.RoleID == nil { + return nil, errors.New("role_id is required") + } + + ctx := r.Context() + + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.UserID) + if err != nil { + return nil, err + } + if user == nil { + return nil, errors.New("user not found") + } + + role, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, *req.RoleID) + if err != nil { + return nil, err + } + if role == nil { + return nil, errors.New("role not found") + } + + existingRoles, _, err := s.ipc.Database.UserRole.GetUserRolesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserRole{ + UserID: req.UserID, + RoleID: req.RoleID, + }, + }) + if err != nil { + return nil, err + } + if len(existingRoles) > 0 { + return nil, errors.New("this role is already assigned to the user") + } + + userRoleObj := &typescore.UserRole{ + UserID: req.UserID, + RoleID: req.RoleID, + } + + createdUserRole, _, err := s.ipc.Database.UserRole.CreateUserRoleDB(ctx, nil, userRoleObj, true) + if err != nil { + return nil, err + } + + createdUserRole.Role = role + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "create", "user_role", createdUserRole.ID, + fmt.Sprintf("Назначена роль «%s» пользователю «%s»", roleLabel(role), userLabel(user)), + map[string]interface{}{ + "user_id": *req.UserID, + "role_id": *req.RoleID, + }, + ) + } + + return createdUserRole, nil +} + +// RemoveUserRoleHandler Удаление роли у пользователя +// @Summary Удаление роли у пользователя +// @Description Удаление связи user_id + role_id по ID записи +// @Tags user-roles +// @Accept json +// @Produce json +// @Param request body typescore.UserRole true "ID записи для удаления" +// @Success 200 {object} bool "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Запись не найдена" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/user-roles [delete] +func (s *UserRolesReg) RemoveUserRoleHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + defer r.Body.Close() + + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 RemoveUserRoleHandler: ReadAll error:", err) + return nil, err + } + + var req typescore.UserRole + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("user_role id is required") + } + + ctx := r.Context() + + existingRoles, _, err := s.ipc.Database.UserRole.GetUserRolesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserRole{ID: req.ID}, + }) + if err != nil { + return nil, err + } + if len(existingRoles) == 0 { + return nil, errors.New("user_role not found") + } + existing := existingRoles[0] + s.enrichUserRolesBatch(ctx, existingRoles) + + var user *typescore.User + if existing.UserID != nil { + user, _ = s.ipc.Database.User.GetUserByIDDB(ctx, *existing.UserID) + } + + err = s.ipc.Database.UserRole.DeleteUserRoleDB(ctx, &req) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{} + if existing.UserID != nil { + snapshot["user_id"] = *existing.UserID + } + if existing.RoleID != nil { + snapshot["role_id"] = *existing.RoleID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "user_role", req.ID, + fmt.Sprintf("Снята роль «%s» с пользователя «%s»", roleLabel(existing.Role), userLabel(user)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func userLabel(user *typescore.User) string { + if user == nil || user.FullName == nil { + return "—" + } + return *user.FullName +} + +func roleLabel(role *typescore.Role) string { + if role == nil || role.Name == nil { + return "—" + } + return *role.Name +} + +func roleNames(userRoles []*typescore.UserRole) []string { + names := make([]string, 0, len(userRoles)) + for _, ur := range userRoles { + names = append(names, roleLabel(ur.Role)) + } + return names +} + +func (s *UserRolesReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/user_roles/handlers.go----- + +File: handlers/user_roles/routes.go +Lines: 53 +-----BEGIN handlers/user_roles/routes.go----- +package userroleshandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type UserRolesReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterUserRoleRoutes регистрирует маршруты для группы user-roles +func RegisterUserRoleRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &UserRolesReg{ + ipc: ipc, + } + + // Основной маршрут для управления ролями + r.Route("/api/user-roles", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + // GET /api/user-roles?user_id=X - список ролей пользователя + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetUserRolesListHandler) + + // POST /api/user-roles - назначить роль пользователю + handlers.RegisterRoute(r, http.MethodPost, "/", s.AssignUserRoleHandler) + + // DELETE /api/user-roles - удалить роль у пользователя + handlers.RegisterRoute(r, http.MethodDelete, "/", s.RemoveUserRoleHandler) + + // POST /api/user-roles/bulk - массовое назначение ролей + handlers.RegisterRoute(r, http.MethodPost, "/bulk", s.BulkAssignRolesHandler) + }) + + // Альтернативный маршрут: GET /api/users/{user_id}/roles + r.Route("/api/users/{user_id}/roles", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + r.Get("/", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetUserRolesByUserIDHandler, + })) + }) + + return nil +} + +-----END handlers/user_roles/routes.go----- + +File: handlers/users/handlers.go +Lines: 417 +-----BEGIN handlers/users/handlers.go----- +package usershandler + +import ( + "bitrix_balancer_api/core/typescore" + "bitrix_balancer_api/core/utilscore" + "bitrix_balancer_api/rest_admin_service/handlers" + adminloghandler "bitrix_balancer_api/rest_admin_service/handlers/admin_actions" + "context" + "encoding/json" + "errors" + "fmt" + "github.com/sirupsen/logrus" + "io" + "net/http" + "strconv" + "strings" + + "github.com/go-chi/chi/v5" +) + +// GetUserListHandler Получение списка пользователей +// @Summary Получение списка пользователей +// @Description Получение списка пользователей с пагинацией, фильтрацией и подгрузкой связанных данных +// @Tags users +// @Accept json +// @Produce json +// @Param offset query integer false "Смещение для пагинации" +// @Param limit query integer false "Количество записей на странице" +// @Param is_blocked query boolean false "Фильтр по блокировке" +// @Param is_fired query boolean false "Фильтр по увольнению" +// @Param department_id query integer false "Фильтр по отделу" +// @Success 200 {object} typescore.ApiResponseBase "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/users [get] +func (s *UserReg) GetUserListHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + queryParams := r.URL.Query() + + userParams := &typescore.User{} + offset, limit, likeFields, errW := utilscore.ParseParamsGetRequest(queryParams, userParams) + if errW != nil { + return nil, errW + } + + search := queryParams.Get("full_name") + if search != "" { + if likeFields == nil { + likeFields = make(map[string]string) + } + likeFields["full_name"] = search + userParams.FullName = nil + } + + var roleIDs []uint64 + if roleIDsStr := queryParams["role_ids[]"]; len(roleIDsStr) > 0 { + for _, idStr := range roleIDsStr { + if id, err := strconv.ParseUint(idStr, 10, 64); err == nil { + roleIDs = append(roleIDs, id) + } + } + } + + options := typescore.ListDbOptions{ + Filtering: userParams, + Offset: offset, + Limit: limit, + LikeFields: likeFields, + } + + ctx := r.Context() + + var userDbLst []*typescore.User + var total uint64 + var err error + + if len(roleIDs) > 0 { + userDbLst, total, err = s.ipc.Database.User.GetUsersListByRoleIDsDB(ctx, options, roleIDs) + } else { + userDbLst, total, err = s.ipc.Database.User.GetUsersListDB(ctx, options) + } + + if err != nil { + return nil, err + } + + s.enrichUsersBatch(ctx, userDbLst) + + return &typescore.ApiResponseBase{ + TotalCount: total, + Data: userDbLst, + }, nil +} + +// UpdateUserHandler Обновление пользователя +// @Summary Обновление пользователя +// @Description Обновление данных существующего пользователя +// @Tags users +// @Accept json +// @Produce json +// @Param request body typescore.UpdateUserReqAdmin true "Данные пользователя" +// @Success 200 {object} typescore.User "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Пользователь не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/users [put] +func (s *UserReg) UpdateUserHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + body, err := io.ReadAll(r.Body) + if err != nil { + logrus.Error("🛑 UpdateUserHandler: ReadAll error:", err) + return nil, err + } + defer r.Body.Close() + + var req typescore.UpdateUserReqAdmin + if err := json.Unmarshal(body, &req); err != nil { + return nil, errors.New("invalid request body") + } + + if req.ID == nil { + return nil, errors.New("user id is required") + } + + ctx := r.Context() + existingUser, err := s.ipc.Database.User.GetUserByIDDB(ctx, *req.ID) + if err != nil { + return nil, err + } + if existingUser == nil { + return nil, errors.New("user not found") + } + + if req.DepartmentID != nil { + if existingUser.DepartmentID == nil || *existingUser.DepartmentID != *req.DepartmentID { + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *req.DepartmentID) + if err != nil { + return nil, err + } + if department == nil { + return nil, errors.New("department not found") + } + } + } + + type fieldChange struct { + Field string `json:"field"` + Old interface{} `json:"old"` + New interface{} `json:"new"` + } + var changes []fieldChange + var summary []string + + if req.DepartmentID != nil && !utilscore.Uint64Eq(existingUser.DepartmentID, req.DepartmentID) { + var oldVal interface{} + if existingUser.DepartmentID != nil { + oldVal = *existingUser.DepartmentID + } + changes = append(changes, fieldChange{"department_id", oldVal, *req.DepartmentID}) + summary = append(summary, "изменён отдел") + } + if req.IsBlocked != nil && !utilscore.BoolEq(existingUser.IsBlocked, req.IsBlocked) { + changes = append(changes, fieldChange{"is_blocked", utilscore.DerefBool(existingUser.IsBlocked), *req.IsBlocked}) + if *req.IsBlocked { + summary = append(summary, "заблокирован") + } else { + summary = append(summary, "разблокирован") + } + } + if req.IsFired != nil && !utilscore.BoolEq(existingUser.IsFired, req.IsFired) { + changes = append(changes, fieldChange{"is_fired", utilscore.DerefBool(existingUser.IsFired), *req.IsFired}) + if *req.IsFired { + summary = append(summary, "уволен") + } else { + summary = append(summary, "восстановлен") + } + } + + upUserObj := &typescore.User{ + ID: req.ID, + DepartmentID: req.DepartmentID, + IsBlocked: req.IsBlocked, + IsFired: req.IsFired, + } + + upUser, _, errW := s.ipc.Database.User.UpdateUserDB(ctx, nil, upUserObj, true) + if errW != nil { + return nil, errW + } + + s.enrichUsersBatch(ctx, []*typescore.User{upUser}) + + if len(changes) > 0 { + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + description := fmt.Sprintf("Изменён пользователь «%s»: %s", userLabel(existingUser), strings.Join(summary, "; ")) + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "update", "user", req.ID, + description, + map[string]interface{}{"changes": changes}, + ) + } + } + + return upUser, nil +} + +// enrichUsersBatch пакетно подгружает отделы и роли для списка пользователей +func (s *UserReg) enrichUsersBatch(ctx context.Context, users []*typescore.User) { + if len(users) == 0 { + return + } + + departmentIDsSet := make(map[uint64]struct{}) + userIDs := make([]uint64, 0, len(users)) + for _, u := range users { + if u.ID != nil { + userIDs = append(userIDs, *u.ID) + } + if u.DepartmentID != nil { + departmentIDsSet[*u.DepartmentID] = struct{}{} + } + } + + departmentIDs := make([]uint64, 0, len(departmentIDsSet)) + for id := range departmentIDsSet { + departmentIDs = append(departmentIDs, id) + } + + departmentsMap := make(map[uint64]*typescore.Department) + if departments, err := s.ipc.Database.Department.GetDepartmentsByIDsDB(ctx, departmentIDs); err == nil { + for _, d := range departments { + if d.ID != nil { + departmentsMap[*d.ID] = d + } + } + } + + userRoles, err := s.ipc.Database.UserRole.GetUserRolesByUserIDsDB(ctx, userIDs) + roleIDsSet := make(map[uint64]struct{}) + userRolesByUser := make(map[uint64][]*typescore.UserRole) + if err == nil { + for _, ur := range userRoles { + if ur.UserID != nil { + userRolesByUser[*ur.UserID] = append(userRolesByUser[*ur.UserID], ur) + } + if ur.RoleID != nil { + roleIDsSet[*ur.RoleID] = struct{}{} + } + } + } + + roleIDs := make([]uint64, 0, len(roleIDsSet)) + for id := range roleIDsSet { + roleIDs = append(roleIDs, id) + } + rolesMap := make(map[uint64]*typescore.Role) + if roles, err := s.ipc.Database.Role.GetRolesByIDsDB(ctx, roleIDs); err == nil { + for _, role := range roles { + if role.ID != nil { + rolesMap[*role.ID] = role + } + } + } + + for _, u := range users { + if u.DepartmentID != nil { + if d, ok := departmentsMap[*u.DepartmentID]; ok { + u.Department = d + } + } + if u.ID == nil { + continue + } + userRolesForUser := userRolesByUser[*u.ID] + for _, ur := range userRolesForUser { + if ur.RoleID != nil { + if role, ok := rolesMap[*ur.RoleID]; ok { + ur.Role = role + } + } + } + if len(userRolesForUser) > 0 { + u.UserRoles = userRolesForUser + } + } +} + +// GetUserByIDHandler Получение пользователя по ID +// @Summary Получение пользователя по ID +// @Description Получение детальной информации о пользователе по его ID с подгрузкой связанных данных +// @Tags users +// @Accept json +// @Produce json +// @Param id path integer true "ID пользователя" +// @Success 200 {object} typescore.User "Успех" +// @Failure 400 {object} handlers.ErrorResponse "Некорректный запрос" +// @Failure 404 {object} handlers.ErrorResponse "Пользователь не найден" +// @Failure 500 {object} handlers.ErrorResponse "Ошибка сервера" +// @Router /api/users/{id} [get] +func (s *UserReg) GetUserByIDHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("user id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid user id") + } + + ctx := r.Context() + user, err := s.ipc.Database.User.GetUserByIDDB(ctx, id) + if err != nil { + return nil, err + } + + if user == nil { + return nil, errors.New("user not found") + } + + if user.DepartmentID != nil { + department, err := s.ipc.Database.Department.GetDepartmentByIDDB(ctx, *user.DepartmentID) + if err == nil && department != nil { + user.Department = department + } + } + + userRoles, _, err := s.ipc.Database.UserRole.GetUserRolesListDB(ctx, typescore.ListDbOptions{ + Filtering: &typescore.UserRole{UserID: user.ID}, + }) + if err == nil && len(userRoles) > 0 { + for _, ur := range userRoles { + if ur.RoleID != nil { + role, err := s.ipc.Database.Role.GetRoleByIDDB(ctx, *ur.RoleID) + if err == nil && role != nil { + ur.Role = role + } + } + } + user.UserRoles = userRoles + } + + return user, nil +} + +func (s *UserReg) DeleteUserHandler(w http.ResponseWriter, r *http.Request) (interface{}, error) { + idStr := chi.URLParam(r, "id") + if idStr == "" { + return nil, errors.New("user id is required") + } + + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid user id") + } + + ctx := r.Context() + + existingUser, err := s.ipc.Database.User.GetUserByIDDB(ctx, id) + if err != nil { + return nil, err + } + if existingUser == nil { + return nil, errors.New("user not found") + } + + err = s.ipc.Database.User.DeleteUserDB(ctx, &typescore.User{ID: &id}) + if err != nil { + return nil, err + } + + if currentAdmin, ok := s.getCurrentAdmin(ctx); ok { + snapshot := map[string]interface{}{ + "full_name": utilscore.DerefStr(existingUser.FullName), + "is_blocked": utilscore.DerefBool(existingUser.IsBlocked), + "is_fired": utilscore.DerefBool(existingUser.IsFired), + } + if existingUser.TelegramID != nil { + snapshot["telegram_id"] = *existingUser.TelegramID + } + if existingUser.DepartmentID != nil { + snapshot["department_id"] = *existingUser.DepartmentID + } + adminloghandler.LogAdminActionWithMetadata( + ctx, s.ipc, + *currentAdmin.ID, *currentAdmin.Login, + "delete", "user", &id, + fmt.Sprintf("Удалён пользователь «%s»", userLabel(existingUser)), + map[string]interface{}{"snapshot": snapshot}, + ) + } + + return true, nil +} + +func userLabel(user *typescore.User) string { + if user == nil || user.FullName == nil { + return "—" + } + return *user.FullName +} + +func (s *UserReg) getCurrentAdmin(ctx context.Context) (*typescore.Admin, bool) { + currentUserID, err := handlers.GetIDFromContext(ctx) + if err != nil { + return nil, false + } + + admins, _, err := s.ipc.Database.Admin.GetAdminsListDB(typescore.ListDbOptions{ + Filtering: &typescore.Admin{ID: ¤tUserID}, + }) + if err != nil || len(admins) == 0 || admins[0] == nil || admins[0].ID == nil || admins[0].Login == nil { + return nil, false + } + + return admins[0], true +} + +-----END handlers/users/handlers.go----- + +File: handlers/users/routes.go +Lines: 39 +-----BEGIN handlers/users/routes.go----- +package usershandler + +import ( + "bitrix_balancer_api/rest_admin_service/handlers" + typesm "bitrix_balancer_api/rest_admin_service/types" + "net/http" + + "github.com/go-chi/chi/v5" +) + +type UserReg struct { + ipc *typesm.InternalProviderControl +} + +// RegisterUserRoutes регистрирует маршруты для группы users +func RegisterUserRoutes( + r chi.Router, + ipc *typesm.InternalProviderControl, +) error { + s := &UserReg{ + ipc: ipc, + } + + r.Route("/api/users", func(r chi.Router) { + r.Use(handlers.AccessCodeVerifier(ipc.Config)) + r.Use(handlers.JWTVerifier(ipc.Config, ipc.Database.Admin, ipc.RedisClient)) + + handlers.RegisterRoute(r, http.MethodGet, "/", s.GetUserListHandler) + handlers.RegisterRoute(r, http.MethodPut, "/", s.UpdateUserHandler) + + handlers.RegisterRoute(r, http.MethodDelete, "/{id}", s.DeleteUserHandler) + + r.Get("/{id}", handlers.WrapHandlerF(handlers.WrapHandlerParams{ + HandlerFunc: s.GetUserByIDHandler, + })) + }) + + return nil +} + +-----END handlers/users/routes.go----- + +File: types/module.go +Lines: 15 +-----BEGIN types/module.go----- +package typesm + +import ( + configcore "bitrix_balancer_api/core/config" + database "bitrix_balancer_api/core/db" + "bitrix_balancer_api/core/lib/external/tgkit" + redismodule "bitrix_balancer_api/core/lib/internally/redis" +) + +type InternalProviderControl struct { + Config *configcore.Config + RedisClient *redismodule.ModuleRedis + TGBotClient *tgkit.Client + Database *database.ModuleDB +} + +-----END types/module.go----- + +File: types/req.go +Lines: 13 +-----BEGIN types/req.go----- +package typesm + +type LimitRequest struct { + Limit uint64 `json:"limit"` + Offset uint64 `json:"offset"` +} + +type Response struct { + TotalCount *uint64 `json:"total_count,omitempty"` + Count int `json:"count,omitempty"` + Error *string `json:"error,omitempty"` + Data interface{} `json:"data,omitempty"` +} + +-----END types/req.go----- + diff --git a/service/rest_admin_service/handlers/approvals/handlers.go b/service/rest_admin_service/handlers/approvals/handlers.go index bec9666..10ea7e6 100644 --- a/service/rest_admin_service/handlers/approvals/handlers.go +++ b/service/rest_admin_service/handlers/approvals/handlers.go @@ -59,6 +59,13 @@ func (s *ApprovalsReg) GetApprovalsListHandler(w http.ResponseWriter, r *http.Re } filter.DepartmentID = &id } + if idStr := queryParams.Get("id"); idStr != "" { + id, err := strconv.ParseUint(idStr, 10, 64) + if err != nil { + return nil, errors.New("invalid id") + } + filter.ID = &id + } contentSearch := queryParams.Get("content") if contentSearch != "" { -- 2.43.0