TaskAPI/Messaging/TaskApiServer.cs - master - ilyamikhaylov07/integration_solution_course

TaskAPI/Messaging/TaskApiServer.cs
243 строки9 KB
Ilya
add 4 laba
02 ноя 2025, 19:16
02 ноя 2025, 19:16fdd8d01
using System.Text;
using System.Text.Json;
using TaskAPI.DTOs.AuthDTOs;
using TaskAPI.DTOs.ProjectsDTOs;
using TaskAPI.DTOs.TasksItemDTOs;
using TaskAPI.DTOs.UsersDTOs;
using TaskAPI.Messaging;
using TaskAPI.Messaging.Models;
using TaskAPI.Services;

public class TaskApiServer
{
    private readonly RabbitMqService _rabbitMqService;
    private readonly TaskAPISenderService _senderService;

    private readonly UsersService _usersService;
    private readonly ProjectsService _projectsService;
    private readonly TasksService _tasksService;
    private readonly AuthService _authService;

    private const string RequestQueue = "api.requests";
    private const string ResponseQueue = "api.responses";
    private const string DLQ = "api.requests.dlq";

    private readonly Dictionary<string, Func<object?, Task<object?>>> _actions;

    public TaskApiServer(RabbitMqService rabbitMqService,
                         UsersService usersService,
                         ProjectsService projectsService,
                         TasksService tasksService,
                         AuthService authService)
    {
        _rabbitMqService = rabbitMqService;
        _senderService = new TaskAPISenderService(_rabbitMqService);

        _usersService = usersService;
        _projectsService = projectsService;
        _tasksService = tasksService;
        _authService = authService;

        _rabbitMqService.DeclareQueueAsync(RequestQueue).GetAwaiter().GetResult();
        _rabbitMqService.DeclareQueueAsync(ResponseQueue).GetAwaiter().GetResult();
        _rabbitMqService.DeclareQueueAsync(DLQ).GetAwaiter().GetResult();

        // Инициализация словаря действий
        _actions = new Dictionary<string, Func<object?, Task<object?>>>
        {
            // Users
            ["create_user"] = async data => {
                var dto = JsonSerializer.Deserialize<CreateUserDTO>(data.ToString()!);
                return await _usersService.CreateUserAsync(dto);
            },
            ["get_user"] = async data => {
                var id = Guid.Parse(data.ToString()!);
                return await _usersService.GetUserAsync(id);
            },
            ["get_all_users"] = async data =>
            {
                string? include = null;

                // data приходит как JsonElement, извлекаем поле Include
                if (data is JsonElement json && json.TryGetProperty("Include", out var includeProp))
                    include = includeProp.GetString();

                var users = await _usersService.GetAllUserAsync(include);

                return new ResponseMessage
                {
                    CorrelationId = Guid.NewGuid().ToString(),
                    Status = "ok",
                    Data = users
                };
            },

            // Projects
            ["create_project"] = async data => {
                var dto = JsonSerializer.Deserialize<CreateProjectDTO>(data.ToString()!);
                return await _projectsService.CreateProjectAsync(dto);
            },
            ["get_project"] = async data => {
                var id = Guid.Parse(data.ToString()!);
                return await _projectsService.GetProjectAsync(id);
            },
            ["get_all_projects"] = async _ => await _projectsService.GetAllProjectAsync(),
            ["update_project"] = async data => {
                var obj = JsonSerializer.Deserialize<Dictionary<string, object>>(data.ToString()!);
                var id = Guid.Parse(obj["Id"].ToString()!);
                var dto = JsonSerializer.Deserialize<CreateProjectDTO>(obj["Data"].ToString()!);
                return await _projectsService.UpdateProjectAsync(id, dto);
            },
            ["delete_project"] = async data => {
                var id = Guid.Parse(data.ToString()!);
                return await _projectsService.DeleteProjectAsync(id);
            },

            // Tasks
            ["get_all_tasks_v2"] = async _ =>
            {
                var tasks = await _tasksService.GetAllTaskV2Async();
                return new ResponseMessage
                {
                    CorrelationId = Guid.NewGuid().ToString(),
                    Status = "ok",
                    Data = tasks
                };
            },
            ["create_task"] = async data => {
                var dto = JsonSerializer.Deserialize<CreateTaskDTO>(data.ToString()!);
                return await _tasksService.CreateTaskAsync(dto);
            },
            ["get_task"] = async data => {
                var id = Guid.Parse(data.ToString()!);
                return await _tasksService.GetTaskAsync(id);
            },
            ["get_all_tasks"] = async _ => await _tasksService.GetAllTaskAsync(),
            ["update_task"] = async data => {
                var obj = JsonSerializer.Deserialize<Dictionary<string, object>>(data.ToString()!);
                var id = Guid.Parse(obj["Id"].ToString()!);
                var dto = JsonSerializer.Deserialize<CreateTaskDTO>(obj["Data"].ToString()!);
                return await _tasksService.UpdateTaskAsync(id, dto);
            },
            ["delete_task"] = async data => {
                var id = Guid.Parse(data.ToString()!);
                return await _tasksService.DeleteTaskAsync(id);
            },

            // Auth
            ["signin"] = async data => {
                var dto = JsonSerializer.Deserialize<LoginDTO>(data.ToString()!);
                return await _authService.GetTokensAsync(dto);
            }
        };
    }

    public async Task HandleMessageAsync(byte[] body)
    {
        var request = JsonSerializer.Deserialize<RequestMessage>(body);
        Console.WriteLine("Получено сообщение: " + Encoding.UTF8.GetString(body));

        // ---------------------- АВТОРИЗАЦИЯ ----------------------
        if (request.Action != "signin" && request.Action != "create_user")
        {
            if (string.IsNullOrEmpty(request.Auth))
            {
                await _senderService.SendAsync(new ResponseMessage
                {
                    CorrelationId = request.Id,
                    Status = "error",
                    Error = "AUTH_REQUIRED"
                }, ResponseQueue);
                return;
            }

            var userId = _authService.ValidateToken(request.Auth);
            if (userId == null)
            {
                await _senderService.SendAsync(new ResponseMessage
                {
                    CorrelationId = request.Id,
                    Status = "error",
                    Error = "INVALID_TOKEN"
                }, ResponseQueue);
                return;
            }
        }
        // ---------------------- /АВТОРИЗАЦИЯ ----------------------

        object? result = null;
        string? error = null;

        try
        {
            if (_actions.TryGetValue(request.Action, out var action))
            {
                try
                {
                    result = await ExecuteWithRetryAsync(() => action(request.Data));
                    if (result == null)
                        error = "Объект не найден или операция не удалась";
                }
                catch (Exception ex)
                {
                    error = ex.Message;
                    LogError(ex, $"Action: {request.Action}, CorrelationId: {request.Id}");

                    // отправка в DLQ
                    await _senderService.SendAsync(body, DLQ);
                }
            }
        }
        catch (Exception ex)
        {
            error = ex.Message;
        }

        var response = new ResponseMessage
        {
            CorrelationId = request.Id,
            Status = error == null ? "ok" : "error",
            Data = result,
            Error = error
        };

        await _senderService.SendAsync(response, ResponseQueue);
    }

    private async Task<object?> ExecuteWithRetryAsync(Func<Task<object?>> action, int maxRetries = 3, int delayMs = 1000)
    {
        int attempt = 0;
        while (true)
        {
            try
            {
                return await action();
            }
            catch (Exception ex)
            {
                attempt++;
                if (attempt >= maxRetries)
                {
                    throw; // если превысили maxRetries, пробрасываем дальше
                }

                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"Попытка {attempt} не удалась: {ex.Message}. Повтор через {delayMs} мс...");
                Console.ResetColor();

                await Task.Delay(delayMs);
            }
        }
    }

    private void LogError(Exception ex, string context)
    {
        string log = $"[{DateTime.Now}] Ошибка в {context}: {ex}\n";
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine(log);
        Console.ResetColor();

        System.IO.File.AppendAllText("errors.log", log);
    }

}