parr_api/PARR.TemplateMatcher/MqTemplateMatcher.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using PARR.Core.Common.Interfaces;
using PARR.Core.Common.Interfaces.RabbitServices;
using PARR.Domain.Common.Rabbit.Messages;
using PARR.Domain.Enums;
using PARR.TemplateMatcher.Services.Interfaces;
using PARR.TemplateMatcher.Settings;

namespace PARR.TemplateMatcher
{
    internal class MqTemplateMatcher : IMqTemplateMatcher
    {
        private readonly ILogger<MqTemplateMatcher> logger;
        private readonly MqSettings mqSettings;
        private readonly IRabbitService mqService;
        private readonly ITransformService transformService;
        private readonly IServiceProvider serviceProvider;

        public MqTemplateMatcher(
            ILogger<MqTemplateMatcher> logger,
            MqSettings mqSettings,
            IRabbitService mqService,
            ITransformService transformService,
            IServiceProvider serviceProvider
            )
        {
            this.logger = logger;
            this.mqSettings = mqSettings;
            this.mqService = mqService;
            this.transformService = transformService;
            this.serviceProvider = serviceProvider;
        }


        public async Task StartAsync()
        {
            logger.LogInformation("Запускаем обработчик TemplateMatcher для очереди {QueueName}", mqSettings.TemplateMatcher.QueueName);

            var isConnected = await mqService.InitConsumerAsync(mqSettings.TemplateMatcher, HandleMessageAsync);

            if (!isConnected)
            {
                logger.LogError("Ошибка при подключении к RabbitMq для очереди {QueueName}", mqSettings.TemplateMatcher.QueueName);
                throw new Exception("Ошибка при подключении к RabbitMq");
            }

            logger.LogInformation("Успешно подключились к RabbitMq для очереди {QueueName}", mqSettings.TemplateMatcher.QueueName);
        }


        private async Task HandleMessageAsync(string msg)
        {
            logger.LogDebug("Получили запрос: {Message}", msg);

            var query = transformService.GetModelFromJson<TemplateMatcherMq>(msg);
            if (query == null)
            {
                logger.LogWarning("Не удалось десериализовать сообщение в TemplateMatcherMq: {Message}", msg);
                return;
            }

            logger.LogTrace("Обрабатываем сообщение: EntityId={EntityId}, EntityType={EntityType}, Action={Action}",
                query.Id, query.EntityType, query.Action);

            await using (var scope = serviceProvider.CreateAsyncScope())
            {
                var templateMatcherService = GetServiceInScope<ITemplateMatcher>(scope);

                switch (query.EntityType)
                {
                    case SyncTaskEntityTypeEnum.Job:
                        var jobValidatorService = GetServiceInScope<IJobValidatorService>(scope);
                        if (!await jobValidatorService.IsValidJobAsync(query.Id))
                        {
                            logger.LogWarning("Сущность {EntityType} с Id {Id} не прошла валидацию", query.EntityType, query.Id);
                            return;
                        }

                        logger.LogDebug("Сущность {EntityType} с Id {Id} прошла валидацию", query.EntityType, query.Id);

                        switch (query.Action)
                        {
                            case TemplateMatcherActionEnum.Sync:
                                // Создать недостающие шаблоны, привязать к нужному Job, включить/выключить по фильтрам
                                await templateMatcherService.SyncTemplatesForJob(query.Id, query.Initiator);
                                break;
                            case TemplateMatcherActionEnum.Update:
                                // Обновить существующие шаблоны: имя, привязка к Job, вкл/выкл по фильтрам
                                await templateMatcherService.UpdateTemplatesForJob(query.Id, query.Initiator);
                                break;
                            default:
                                logger.LogWarning("Неизвестное действие для {EntityType}: {Action}", query.EntityType, query.Action);
                                break;
                        }
                        break;

                    case SyncTaskEntityTypeEnum.JobGroup:
                        var jobGroupValidatorService = GetServiceInScope<IJobGroupValidatorService>(scope);
                        if (!await jobGroupValidatorService.IsValidJobGroupAsync(query.Id))
                        {
                            logger.LogWarning("Сущность {EntityType} с Id {Id} не прошла валидацию", query.EntityType, query.Id);
                            return;
                        }

                        logger.LogDebug("Сущность {EntityType} с Id {Id} прошла валидацию", query.EntityType, query.Id);

                        switch (query.Action)
                        {
                            case TemplateMatcherActionEnum.Sync:
                                await templateMatcherService.SyncTemplatesForJobGroup(query.Id, query.Initiator);
                                break;

                            case TemplateMatcherActionEnum.Update:
                                //await templateMatcherService.UpdateTemplatesForJob(query.Id, query.Initiator);
                                await templateMatcherService.UpdateTemplatesForJobGroup(query.Id, query.Initiator);
                                break;

                            default:
                                logger.LogWarning("Неизвестное действие для {EntityType}: {Action}", query.EntityType, query.Action);
                                break;
                        }
                        break;
                    case SyncTaskEntityTypeEnum.Template:
                        logger.LogWarning("Обработка EntityType Template не реализована. Id: {Id}, Action: {Action}", query.Id, query.Action);
                        break;

                    default:
                        logger.LogWarning("Неизвестный тип сущности: {EntityType}", query.EntityType);
                        break;
                }
            }

            logger.LogDebug("Обработка сообщения завершена: {Message}", msg);
        }


        public async Task StopAsync()
        {
            logger.LogInformation("Останавливаем обработчик TemplateMatcher");
            await mqService.DisposeAsync();
            logger.LogInformation("Обработчик TemplateMatcher остановлен");
        }


        private Service GetServiceInScope<Service>(IServiceScope scope)
        {
            var service = scope.ServiceProvider.GetService<Service>();
            if (service == null)
                throw new Exception($"Не найден сервис: {nameof(Service)}");

            return service;
        }
    }
}