[Назад](/README.md)

# C4 Architecture Diagrams - TaskManager

## Содержание
1. [Level 1: System Context](#level-1-system-context)
2. [Level 2: Container Diagram](#level-2-container-diagram)
3. [Level 3: Component Diagram - Tasks Service](#level-3-component-diagram---tasks-service)
4. [Level 3: Component Diagram - Adapter Layer](#level-3-component-diagram---adapter-layer)

---

## Level 1: System Context

Показывает TaskManager в контексте пользователей и внешних систем.

```mermaid
C4Context
    title System Context diagram for TaskManager

    Person(hotel_staff, "Hotel Staff", "Сотрудники отеля (горничные, техники, менеджеры)")
    Person(admin, "System Admin", "Администратор системы")
    Person(guest, "Hotel Guest", "Гость отеля")

    System(taskmanager, "TaskManager", "Платформа для управления задачами между подразделениями отеля и интеграции с внешними системами")

    System_Ext(pms, "PMS System", "Система управления отелем (Opera, Fidelio)")
    System_Ext(erp, "ERP System", "Система управления ресурсами")
    System_Ext(housekeeping, "Housekeeping App", "Приложение для управления уборкой")
    System_Ext(email, "Email System", "SMTP сервер для отправки email")
    System_Ext(sms, "SMS Gateway", "Сервис отправки SMS (Twilio)")
    System_Ext(telegram, "Telegram", "Telegram Bot API")
    System_Ext(s3, "AWS S3", "Хранилище файлов")

    Rel(hotel_staff, taskmanager, "Создает и управляет задачами", "Web/Mobile")
    Rel(admin, taskmanager, "Настраивает систему, связи, роли", "Web Admin")
    Rel(guest, taskmanager, "Создает запросы на обслуживание", "Telegram Bot")

    Rel(taskmanager, pms, "Получает/отправляет данные о бронированиях, номерах", "REST API/Webhook")
    Rel(taskmanager, erp, "Интегрируется с учетом ресурсов", "REST API")
    Rel(taskmanager, housekeeping, "Отправляет задачи на уборку", "REST API/Push")
    Rel(taskmanager, email, "Отправляет уведомления", "SMTP")
    Rel(taskmanager, sms, "Отправляет SMS уведомления", "REST API")
    Rel(taskmanager, telegram, "Получает запросы гостей, отправляет уведомления", "Webhook/Bot API")
    Rel(taskmanager, s3, "Хранит файлы и фото", "S3 API")

    UpdateLayoutConfig($c4ShapeInRow="3", $c4BoundaryInRow="2")
```

---

## Level 2: Container Diagram

Показывает основные контейнеры (приложения и хранилища данных) внутри TaskManager.

```mermaid
C4Container
    title Container diagram for TaskManager

    Person(hotel_staff, "Hotel Staff", "Сотрудники отеля")
    Person(admin, "System Admin", "Администратор системы")
    Person(guest, "Hotel Guest", "Гость отеля")

    System_Ext(pms, "PMS System", "Opera/Fidelio")
    System_Ext(erp, "ERP System", "ERP")
    System_Ext(housekeeping_ext, "Housekeeping App", "External App")
    System_Ext(email_ext, "Email System", "SMTP")
    System_Ext(sms_ext, "SMS Gateway", "Twilio")
    System_Ext(telegram_ext, "Telegram", "Bot API")
    System_Ext(s3_ext, "AWS S3", "File Storage")

    Container_Boundary(taskmanager, "TaskManager System") {

        Container(web_admin, "Web Admin", "React, TypeScript", "Веб-приложение для настройки системы и управления")
        Container(mobile_app, "Mobile App", "React Native/Flutter", "Мобильное приложение для сотрудников")

        Container(api_gateway, "API Gateway", "Kong/Envoy", "Единая точка входа, маршрутизация, аутентификация")

        Container(tasks_service, "Tasks Service", "Python, FastAPI, gRPC", "Управление задачами")
        Container(connections_service, "Connections Service", "Python, FastAPI, gRPC", "Управление связями между адаптерами")
        Container(users_service, "Users Service", "Python, FastAPI, gRPC", "Управление пользователями")
        Container(permissions_service, "Permissions Service", "Python, FastAPI, gRPC", "Управление ролями и правами (RBAC)")
        Container(notification_service, "Notification Service", "Python, FastAPI", "Отправка уведомлений через разные каналы")
        Container(file_storage_service, "File Storage Service", "Python, FastAPI", "Управление файлами")
        Container(audit_service, "Audit Service", "Python, FastAPI", "Логирование всех действий")
        Container(scheduler_service, "Scheduler Service", "Python, FastAPI", "Управление периодическими задачами")
        Container(events_service, "Events Service", "Python, FastAPI, gRPC", "Управление мероприятиями")

        Container(pms_adapter, "PMS Adapter", "Python", "Адаптер для PMS системы")
        Container(erp_adapter, "ERP Adapter", "Python", "Адаптер для ERP системы")
        Container(housekeeping_adapter, "Housekeeping Adapter", "Python", "Адаптер для приложения уборки")
        Container(telegram_adapter, "Telegram Bot Adapter", "Python", "Адаптер для Telegram бота")

        ContainerQueue(kafka, "Message Broker", "Apache Kafka", "Асинхронная коммуникация между сервисами")

        ContainerDb(postgres, "Database", "PostgreSQL", "Хранение данных системы")
        ContainerDb(redis, "Cache", "Redis", "Кэширование данных, сессии")
    }

    Rel(hotel_staff, web_admin, "Использует", "HTTPS")
    Rel(hotel_staff, mobile_app, "Использует", "HTTPS")
    Rel(admin, web_admin, "Настраивает систему", "HTTPS")
    Rel(guest, telegram_adapter, "Отправляет запросы", "Telegram")

    Rel(web_admin, api_gateway, "Делает API запросы", "REST/gRPC-Web")
    Rel(mobile_app, api_gateway, "Делает API запросы", "REST/gRPC")

    Rel(api_gateway, tasks_service, "Маршрутизирует запросы", "gRPC")
    Rel(api_gateway, users_service, "Маршрутизирует запросы", "gRPC")
    Rel(api_gateway, connections_service, "Маршрутизирует запросы", "gRPC")
    Rel(api_gateway, events_service, "Маршрутизирует запросы", "gRPC")
    Rel(api_gateway, file_storage_service, "Маршрутизирует запросы", "REST")

    Rel(tasks_service, kafka, "Публикует события", "Kafka Protocol")
    Rel(connections_service, kafka, "Публикует/читает события", "Kafka Protocol")
    Rel(scheduler_service, kafka, "Публикует триггеры", "Kafka Protocol")
    Rel(events_service, kafka, "Публикует события", "Kafka Protocol")
    Rel(notification_service, kafka, "Читает события", "Kafka Protocol")
    Rel(audit_service, kafka, "Читает все события", "Kafka Protocol")

    Rel(tasks_service, permissions_service, "Проверяет права", "gRPC")
    Rel(users_service, permissions_service, "Проверяет права", "gRPC")

    Rel(pms_adapter, kafka, "Публикует сообщения", "Kafka Protocol")
    Rel(erp_adapter, kafka, "Публикует сообщения", "Kafka Protocol")
    Rel(housekeeping_adapter, kafka, "Публикует сообщения", "Kafka Protocol")
    Rel(telegram_adapter, kafka, "Публикует сообщения", "Kafka Protocol")

    Rel(pms_adapter, pms, "Получает/отправляет данные", "REST API/Webhook")
    Rel(erp_adapter, erp, "Получает/отправляет данные", "REST API")
    Rel(housekeeping_adapter, housekeeping_ext, "Отправляет задачи", "REST API/Push")
    Rel(telegram_adapter, telegram_ext, "Взаимодействует с ботом", "Webhook/Bot API")

    Rel(notification_service, email_ext, "Отправляет email", "SMTP")
    Rel(notification_service, sms_ext, "Отправляет SMS", "REST API")
    Rel(notification_service, telegram_ext, "Отправляет сообщения", "Bot API")

    Rel(file_storage_service, s3_ext, "Хранит файлы", "S3 API")

    Rel(tasks_service, postgres, "Читает/пишет данные", "SQL")
    Rel(users_service, postgres, "Читает/пишет данные", "SQL")
    Rel(connections_service, postgres, "Читает/пишет данные", "SQL")
    Rel(permissions_service, postgres, "Читает/пишет данные", "SQL")
    Rel(scheduler_service, postgres, "Читает/пишет данные", "SQL")
    Rel(events_service, postgres, "Читает/пишет данные", "SQL")
    Rel(audit_service, postgres, "Пишет логи", "SQL")
    Rel(file_storage_service, postgres, "Пишет метаданные", "SQL")

    Rel(tasks_service, redis, "Кэширует данные", "Redis Protocol")
    Rel(users_service, redis, "Кэширует данные", "Redis Protocol")
    Rel(permissions_service, redis, "Кэширует права", "Redis Protocol")

    UpdateLayoutConfig($c4ShapeInRow="4", $c4BoundaryInRow="2")
```

---

## Level 3: Component Diagram - Tasks Service

Показывает внутреннюю структуру Tasks Service.

```mermaid
C4Component
    title Component diagram for Tasks Service

    Container_Ext(api_gateway, "API Gateway", "Kong/Envoy", "Точка входа")
    Container_Ext(kafka, "Kafka", "Apache Kafka", "Message Broker")
    ContainerDb_Ext(postgres, "PostgreSQL", "Database", "Основная БД")
    ContainerDb_Ext(redis, "Redis", "Cache", "Кэш")
    Container_Ext(permissions_service, "Permissions Service", "Python, gRPC", "Проверка прав")
    Container_Ext(file_storage_service, "File Storage Service", "Python", "Управление файлами")

    Container_Boundary(tasks_service, "Tasks Service") {

        Component(grpc_api, "gRPC API", "Python, gRPC", "Обработка gRPC запросов")
        Component(rest_api, "REST API", "FastAPI", "Обработка REST запросов (fallback)")

        Component(task_controller, "Task Controller", "Python", "Обработка бизнес-логики задач")
        Component(status_controller, "Status Controller", "Python", "Управление статусами задач")
        Component(dependency_controller, "Dependency Controller", "Python", "Управление зависимостями")
        Component(history_controller, "History Controller", "Python", "Управление историей изменений")

        Component(task_repository, "Task Repository", "SQLAlchemy", "Работа с БД задач")
        Component(status_repository, "Status Repository", "SQLAlchemy", "Работа с БД статусов")
        Component(dependency_repository, "Dependency Repository", "SQLAlchemy", "Работа с БД зависимостей")
        Component(history_repository, "History Repository", "SQLAlchemy", "Работа с БД истории")

        Component(kafka_producer, "Kafka Producer", "aiokafka", "Публикация событий в Kafka")
        Component(kafka_consumer, "Kafka Consumer", "aiokafka", "Чтение событий из Kafka")

        Component(cache_manager, "Cache Manager", "Redis Client", "Управление кэшем")
        Component(permission_client, "Permission Client", "gRPC Client", "Проверка прав доступа")

        Component(task_validator, "Task Validator", "Pydantic", "Валидация данных задач")
        Component(event_mapper, "Event Mapper", "Python", "Маппинг событий")
    }

    Rel(api_gateway, grpc_api, "Отправляет gRPC запросы", "gRPC")
    Rel(api_gateway, rest_api, "Отправляет REST запросы", "HTTP/JSON")

    Rel(grpc_api, task_controller, "Вызывает методы")
    Rel(rest_api, task_controller, "Вызывает методы")

    Rel(task_controller, task_validator, "Валидирует данные")
    Rel(task_controller, permission_client, "Проверяет права")
    Rel(task_controller, task_repository, "Работает с задачами")
    Rel(task_controller, status_controller, "Изменяет статусы")
    Rel(task_controller, dependency_controller, "Управляет зависимостями")
    Rel(task_controller, history_controller, "Записывает историю")
    Rel(task_controller, cache_manager, "Кэширует данные")
    Rel(task_controller, kafka_producer, "Публикует события")

    Rel(status_controller, status_repository, "Работает со статусами")
    Rel(dependency_controller, dependency_repository, "Работает с зависимостями")
    Rel(history_controller, history_repository, "Работает с историей")

    Rel(kafka_consumer, event_mapper, "Маппит события")
    Rel(event_mapper, task_controller, "Обрабатывает события")

    Rel(task_repository, postgres, "Выполняет SQL запросы", "SQL")
    Rel(status_repository, postgres, "Выполняет SQL запросы", "SQL")
    Rel(dependency_repository, postgres, "Выполняет SQL запросы", "SQL")
    Rel(history_repository, postgres, "Выполняет SQL запросы", "SQL")

    Rel(cache_manager, redis, "Кэширует/читает данные", "Redis Protocol")
    Rel(permission_client, permissions_service, "Проверяет права", "gRPC")

    Rel(kafka_producer, kafka, "Публикует события", "Kafka Protocol")
    Rel(kafka_consumer, kafka, "Читает события", "Kafka Protocol")

    UpdateLayoutConfig($c4ShapeInRow="3", $c4BoundaryInRow="1")
```

---

## Level 3: Component Diagram - Adapter Layer

Показывает внутреннюю структуру адаптера (на примере PMS Adapter).

```mermaid
C4Component
    title Component diagram for PMS Adapter (Example)

    System_Ext(pms_system, "PMS System", "Opera/Fidelio", "Внешняя PMS система")
    Container_Ext(kafka, "Kafka", "Apache Kafka", "Message Broker")
    Container_Ext(postgres, "PostgreSQL", "Database", "Хранение состояния адаптера")

    Container_Boundary(pms_adapter, "PMS Adapter") {

        Component(webhook_handler, "Webhook Handler", "FastAPI", "Принимает webhook от PMS")
        Component(api_poller, "API Poller", "Python, APScheduler", "Опрашивает PMS API по расписанию")
        Component(rest_client, "REST Client", "httpx", "HTTP клиент для PMS API")

        Component(inbound_transformer, "Inbound Transformer", "Python", "PMS формат → Стандартный формат")
        Component(outbound_transformer, "Outbound Transformer", "Python", "Стандартный формат → PMS формат")

        Component(message_validator, "Message Validator", "Pydantic", "Валидация сообщений")
        Component(event_publisher, "Event Publisher", "aiokafka", "Публикация событий в Kafka")
        Component(event_consumer, "Event Consumer", "aiokafka", "Чтение событий из Kafka")

        Component(state_manager, "State Manager", "SQLAlchemy", "Управление состоянием синхронизации")
        Component(error_handler, "Error Handler", "Python", "Обработка ошибок и retry")
        Component(config_manager, "Config Manager", "Python", "Управление конфигурацией")
    }

    Rel(pms_system, webhook_handler, "Отправляет webhook", "HTTP/JSON")
    Rel(api_poller, rest_client, "Запрашивает данные")
    Rel(rest_client, pms_system, "Делает API запросы", "REST/SOAP")

    Rel(webhook_handler, inbound_transformer, "Передает данные")
    Rel(api_poller, inbound_transformer, "Передает данные")

    Rel(inbound_transformer, message_validator, "Валидирует сообщение")
    Rel(message_validator, event_publisher, "Публикует валидное событие")

    Rel(event_consumer, kafka, "Читает исходящие события", "Kafka Protocol")
    Rel(event_consumer, outbound_transformer, "Передает событие")
    Rel(outbound_transformer, rest_client, "Отправляет в PMS")

    Rel(event_publisher, kafka, "Публикует входящие события", "Kafka Protocol")

    Rel(state_manager, postgres, "Сохраняет состояние", "SQL")
    Rel(error_handler, state_manager, "Логирует ошибки")

    Rel(webhook_handler, error_handler, "Обрабатывает ошибки")
    Rel(api_poller, error_handler, "Обрабатывает ошибки")
    Rel(rest_client, error_handler, "Обрабатывает ошибки")

    Rel(config_manager, api_poller, "Предоставляет конфигурацию")
    Rel(config_manager, rest_client, "Предоставляет конфигурацию")

    UpdateLayoutConfig($c4ShapeInRow="3", $c4BoundaryInRow="1")
```

---

## Deployment Diagram (Kubernetes)

Показывает развертывание в Kubernetes кластере.

```mermaid
C4Deployment
    title Deployment Diagram for TaskManager (Kubernetes)

    Deployment_Node(k8s_cluster, "Kubernetes Cluster", "GKE/EKS/AKS") {

        Deployment_Node(ingress_ns, "Namespace: ingress") {
            Container(ingress, "Ingress Controller", "NGINX/Traefik", "Входная точка для внешнего трафика")
        }

        Deployment_Node(gateway_ns, "Namespace: gateway") {
            Container(api_gateway, "API Gateway", "Kong/Envoy", "3 replicas", "Маршрутизация и аутентификация")
        }

        Deployment_Node(services_ns, "Namespace: services") {
            Container(tasks_svc, "Tasks Service", "Python, FastAPI", "5 replicas", "Управление задачами")
            Container(users_svc, "Users Service", "Python, FastAPI", "3 replicas", "Управление пользователями")
            Container(connections_svc, "Connections Service", "Python, FastAPI", "2 replicas", "Управление связями")
            Container(permissions_svc, "Permissions Service", "Python, FastAPI", "3 replicas", "RBAC")
            Container(notification_svc, "Notification Service", "Python, FastAPI", "3 replicas", "Уведомления")
            Container(file_storage_svc, "File Storage Service", "Python, FastAPI", "2 replicas", "Файлы")
            Container(audit_svc, "Audit Service", "Python, FastAPI", "2 replicas", "Аудит")
            Container(scheduler_svc, "Scheduler Service", "Python, FastAPI", "1 replica", "Планировщик")
            Container(events_svc, "Events Service", "Python, FastAPI", "2 replicas", "Мероприятия")
        }

        Deployment_Node(adapters_ns, "Namespace: adapters") {
            Container(pms_adapter, "PMS Adapter", "Python", "2 replicas", "PMS интеграция")
            Container(erp_adapter, "ERP Adapter", "Python", "1 replica", "ERP интеграция")
            Container(housekeeping_adapter, "Housekeeping Adapter", "Python", "2 replicas", "Уборка")
            Container(telegram_adapter, "Telegram Adapter", "Python", "2 replicas", "Telegram бот")
        }

        Deployment_Node(data_ns, "Namespace: data") {
            ContainerDb(postgres_primary, "PostgreSQL Primary", "PostgreSQL 15", "1 pod", "Основная БД (master)")
            ContainerDb(postgres_replica, "PostgreSQL Replica", "PostgreSQL 15", "2 pods", "Реплики для чтения")
            ContainerDb(redis_cluster, "Redis Cluster", "Redis 7", "3 pods", "Кэш и сессии")
            ContainerQueue(kafka_cluster, "Kafka Cluster", "Apache Kafka", "3 brokers", "Message broker")
        }

        Deployment_Node(monitoring_ns, "Namespace: monitoring") {
            Container(prometheus, "Prometheus", "Prometheus", "Сбор метрик")
            Container(grafana, "Grafana", "Grafana", "Визуализация метрик")
            Container(jaeger, "Jaeger", "Jaeger", "Distributed tracing")
        }
    }

    Deployment_Node(external_services, "External Services") {
        Container(s3, "AWS S3", "Object Storage", "Хранилище файлов")
        Container(smtp, "SMTP Server", "Email", "Отправка email")
        Container(sms_gateway, "SMS Gateway", "Twilio", "Отправка SMS")
    }

    Rel(ingress, api_gateway, "Routes traffic", "HTTPS")

    Rel(api_gateway, tasks_svc, "Calls", "gRPC")
    Rel(api_gateway, users_svc, "Calls", "gRPC")
    Rel(api_gateway, connections_svc, "Calls", "gRPC")
    Rel(api_gateway, events_svc, "Calls", "gRPC")
    Rel(api_gateway, file_storage_svc, "Calls", "REST")

    Rel(tasks_svc, kafka_cluster, "Publishes/Consumes", "Kafka Protocol")
    Rel(connections_svc, kafka_cluster, "Publishes/Consumes", "Kafka Protocol")
    Rel(scheduler_svc, kafka_cluster, "Publishes", "Kafka Protocol")
    Rel(notification_svc, kafka_cluster, "Consumes", "Kafka Protocol")
    Rel(audit_svc, kafka_cluster, "Consumes", "Kafka Protocol")

    Rel(pms_adapter, kafka_cluster, "Publishes/Consumes", "Kafka Protocol")
    Rel(erp_adapter, kafka_cluster, "Publishes/Consumes", "Kafka Protocol")
    Rel(housekeeping_adapter, kafka_cluster, "Publishes/Consumes", "Kafka Protocol")
    Rel(telegram_adapter, kafka_cluster, "Publishes/Consumes", "Kafka Protocol")

    Rel(tasks_svc, postgres_primary, "Writes", "SQL")
    Rel(tasks_svc, postgres_replica, "Reads", "SQL")
    Rel(users_svc, postgres_primary, "Writes", "SQL")
    Rel(users_svc, postgres_replica, "Reads", "SQL")
    Rel(audit_svc, postgres_primary, "Writes logs", "SQL")

    Rel(tasks_svc, redis_cluster, "Cache", "Redis Protocol")
    Rel(users_svc, redis_cluster, "Cache", "Redis Protocol")
    Rel(permissions_svc, redis_cluster, "Cache permissions", "Redis Protocol")

    Rel(file_storage_svc, s3, "Stores files", "S3 API")
    Rel(notification_svc, smtp, "Sends emails", "SMTP")
    Rel(notification_svc, sms_gateway, "Sends SMS", "REST API")

    Rel(prometheus, tasks_svc, "Scrapes metrics", "HTTP")
    Rel(prometheus, users_svc, "Scrapes metrics", "HTTP")
    Rel(grafana, prometheus, "Queries metrics", "HTTP")

    UpdateLayoutConfig($c4ShapeInRow="3", $c4BoundaryInRow="1")
```

---

## Sequence Diagram: Creating Task from External System

Показывает последовательность действий при создании задачи из внешней системы.

```mermaid
sequenceDiagram
    participant PMS as PMS System (Opera)
    participant Adapter as PMS Adapter
    participant Kafka as Apache Kafka
    participant Connections as Connections Service
    participant Tasks as Tasks Service
    participant Permissions as Permissions Service
    participant Audit as Audit Service
    participant Notification as Notification Service
    participant DB as PostgreSQL
    participant Housekeeping as Housekeeping Adapter
    participant HK_App as Housekeeping App

    Note over PMS,HK_App: Сценарий: Гость выехал из номера, нужна уборка

    PMS->>Adapter: Webhook: Guest Checkout (Room 305)
    Adapter->>Adapter: Validate webhook signature
    Adapter->>Adapter: Transform to standard format
    Adapter->>Kafka: Publish: adapters.pms.checkout

    Note over Kafka: Topic: adapters.pms.checkout

    Kafka->>Connections: Consume: adapters.pms.checkout
    Connections->>DB: Get routing rules for PMS → TaskManager
    DB-->>Connections: Routing rules
    Connections->>Connections: Apply rules: checkout → create cleaning task
    Connections->>Kafka: Publish: connections.route_task

    Note over Kafka: Topic: connections.route_task

    Kafka->>Tasks: Consume: connections.route_task
    Tasks->>Permissions: CheckPermission(source_adapter, create_task)
    Permissions->>DB: Query permissions
    DB-->>Permissions: Permission granted
    Permissions-->>Tasks: Allowed

    Tasks->>Tasks: Create task object
    Tasks->>DB: INSERT INTO tasks (...)
    DB-->>Tasks: Task created (id: uuid)

    Tasks->>Kafka: Publish: tasks.created

    Note over Kafka: Topic: tasks.created

    par Parallel Processing
        Kafka->>Audit: Consume: tasks.created
        Audit->>DB: INSERT INTO audit_log

        Kafka->>Notification: Consume: tasks.created
        Notification->>DB: Get user notification preferences
        DB-->>Notification: User prefers Telegram
        Notification->>Notification: Send Telegram notification

        Kafka->>Connections: Consume: tasks.created
        Connections->>DB: Get routing rules for TaskManager → Housekeeping
        DB-->>Connections: Route to Housekeeping Adapter
        Connections->>Kafka: Publish: connections.route_task
    end

    Note over Kafka: Topic: connections.route_task

    Kafka->>Housekeeping: Consume: connections.route_task
    Housekeeping->>Housekeeping: Transform to Housekeeping App format
    Housekeeping->>HK_App: POST /api/tasks (Room 305 cleaning)
    HK_App-->>Housekeeping: Task assigned (assignee: Maria)

    Housekeeping->>Kafka: Publish: adapters.housekeeping.task_assigned

    Kafka->>Tasks: Consume: adapters.housekeeping.task_assigned
    Tasks->>DB: UPDATE tasks SET assignee_id = ...
    Tasks->>Kafka: Publish: tasks.assigned

    Note over PMS,HK_App: Task created and assigned to housekeeping staff
```

---

## Sequence Diagram: Creating Event with Auto-Generated Tasks

Показывает создание мероприятия и автоматическую генерацию задач.

```mermaid
sequenceDiagram
    participant User as Sales Manager
    participant Web as Web Admin
    participant Gateway as API Gateway
    participant Events as Events Service
    participant Tasks as Tasks Service
    participant Kafka as Apache Kafka
    participant DB as PostgreSQL
    participant Notification as Notification Service

    Note over User,Notification: Сценарий: Создание конференции на 50 человек

    User->>Web: Create Event: "Marketing Conference"
    Web->>Gateway: POST /api/v1/events (event details)
    Gateway->>Gateway: Authenticate & Authorize

    Gateway->>Events: CreateEvent(gRPC)
    Events->>DB: INSERT INTO events
    DB-->>Events: Event created (id: uuid)

    Events->>Events: Generate tasks from event template
    Note over Events: Tasks: Setup chairs, Prepare projector,<br/>Organize coffee break, etc.

    loop For each generated task
        Events->>Tasks: CreateTask(gRPC)
        Tasks->>DB: INSERT INTO tasks
        DB-->>Tasks: Task created
        Tasks->>Kafka: Publish: tasks.created
        Tasks-->>Events: Task ID
    end

    Events->>DB: INSERT INTO event_tasks (event_id, task_id)
    Events->>Kafka: Publish: events.created
    Events->>Kafka: Publish: events.tasks_generated

    Events-->>Gateway: Event + generated tasks
    Gateway-->>Web: 201 Created (event + tasks)
    Web-->>User: Show created event with tasks

    par Notify departments
        Kafka->>Notification: Consume: tasks.created
        loop For each task
            Notification->>Notification: Get assignee notification prefs
            Notification->>Notification: Send notification (Telegram/Email)
        end
    end

    Note over User,Notification: All tasks created and departments notified
```

---

## Data Flow Diagram

Показывает потоки данных в системе.

```mermaid
flowchart TB
    subgraph External["External Systems"]
        PMS["PMS System"]
        ERP["ERP System"]
        Guest["Guest (Telegram)"]
    end

    subgraph Adapters["Adapter Layer"]
        PMS_A["PMS Adapter"]
        ERP_A["ERP Adapter"]
        TG_A["Telegram Adapter"]
    end

    subgraph Kafka["Apache Kafka"]
        T1["adapters.*"]
        T2["tasks.*"]
        T3["connections.*"]
        T4["notifications.*"]
        T5["audit.*"]
    end

    subgraph Core["Core Services"]
        Connections["Connections Service<br/>(Routing Rules)"]
        Tasks["Tasks Service<br/>(Task Management)"]
        Users["Users Service"]
        Permissions["Permissions Service"]
    end

    subgraph Support["Support Services"]
        Notification["Notification Service"]
        Audit["Audit Service"]
        Scheduler["Scheduler Service"]
    end

    subgraph Data["Data Layer"]
        DB["PostgreSQL"]
        Cache["Redis"]
    end

    %% External to Adapters
    PMS -->|"Webhook/API"| PMS_A
    ERP -->|"API"| ERP_A
    Guest -->|"Telegram Bot"| TG_A

    %% Adapters to Kafka
    PMS_A -->|"Publish events"| T1
    ERP_A -->|"Publish events"| T1
    TG_A -->|"Publish events"| T1

    %% Kafka to Connections
    T1 -->|"Consume"| Connections

    %% Connections routing
    Connections -->|"Route messages"| T3
    T3 -->|"Consume"| Tasks

    %% Tasks operations
    Tasks -->|"Publish events"| T2
    Tasks -->|"Query permissions"| Permissions
    Tasks -->|"Write/Read"| DB
    Tasks -->|"Cache"| Cache

    %% Support services
    T2 -->|"Consume"| Notification
    T2 -->|"Consume"| Audit
    Scheduler -->|"Trigger tasks"| T2

    Notification -->|"Send notifications"| External
    Audit -->|"Write logs"| DB

    %% Users and Permissions
    Users -->|"Write/Read"| DB
    Permissions -->|"Write/Read"| DB
    Permissions -->|"Cache permissions"| Cache

    style Kafka fill:#ff9900
    style Core fill:#00cc66
    style Support fill:#3399ff
    style Data fill:#cc66ff
```

---

## Notes

### Как использовать эти диаграммы:

1. **System Context (Level 1)**: Показывает TaskManager как черный ящик в контексте пользователей и внешних систем. Используйте для презентации бизнес-заказчикам.

2. **Container Diagram (Level 2)**: Показывает основные приложения и хранилища данных. Используйте для обсуждения с архитекторами и DevOps командой.

3. **Component Diagrams (Level 3)**: Показывают внутреннюю структуру отдельных сервисов. Используйте для разработчиков при проектировании конкретного сервиса.

4. **Deployment Diagram**: Показывает как система развернута в Kubernetes. Используйте для DevOps и планирования инфраструктуры.

5. **Sequence Diagrams**: Показывают взаимодействие компонентов во времени для конкретных сценариев. Используйте для понимания бизнес-процессов.