parr_api/PARR.JobAutoControl/JobAutoControlManager.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using PARR.BLL.Domain.Mq;
using PARR.BLL.Services.Interfaces;
using PARR.Constants;
using PARR.DAL.Services.Interfaces;
using PARR.JobAutoControl.Settings;
using System.Text.Json;

namespace PARR.JobAutoControl
{
    internal class JobAutoControlManager : IJobAutoControlManager
    {
        private readonly WorkerSettings workerSettings;
        private readonly ILogger<JobAutoControlManager> logger;
        private readonly IIntervalService intervalService;
        private readonly IServiceProvider serviceProvider;
        private readonly MqSettings mqSettings;

        public JobAutoControlManager(
            WorkerSettings workerSettings,
            ILogger<JobAutoControlManager> logger,
            IIntervalService intervalService,
            IServiceProvider serviceProvider,
            MqSettings mqSettings
            )
        {
            this.workerSettings = workerSettings;
            this.logger = logger;
            this.intervalService = intervalService;
            this.serviceProvider = serviceProvider;
            this.mqSettings = mqSettings;
        }

        public async Task StartAsync()
        {
            logger.LogInformation("Запуск сервиса управления авто-контролем РР (JobAutoControl)");

            await intervalService.IntervalInitAsync(async () =>
            {
                using (var scope = serviceProvider.CreateScope())
                {
                    var jobAutoControlService = scope.ServiceProvider.GetService<IJobAutoControlService>();
                    var mqService = scope.ServiceProvider.GetService<IMqService>();

                    if (jobAutoControlService == null || mqService == null)
                        throw new Exception($"Не смог получить серивс {nameof(IJobAutoControlService)} или {nameof(IMqService)}");

                    await HandlerAsync(jobAutoControlService, mqService);
                }
            }, workerSettings.RepeatEvery);
        }


        private async Task HandlerAsync(IJobAutoControlService jobAutoControlService, IMqService mqService)
        {
            await GenerateAsync(jobAutoControlService, mqService);
            await DeactivateAsync(jobAutoControlService, mqService);
            await ActivateAsync(jobAutoControlService, mqService);
        }


        /// <summary>
        /// Генерировать новые РР
        /// </summary>
        /// <param name="jobAutoControlService"></param>
        /// <param name="mqService"></param>
        /// <returns></returns>
        private async Task GenerateAsync(IJobAutoControlService jobAutoControlService, IMqService mqService)
        {
            var jobsToGenerate = await jobAutoControlService.Get()
               .Include(t => t.JobEkMasks)
               .Include(t => t.JobAutoControlInEkStatuses)
               .Include(t => t.ApplicationsInWork)
               .Where(t => t.CreateNew && t.JobEkMasks.Any() && t.JobAutoControlInEkStatuses.Any())
               .ToListAsync();

            logger.LogInformation($"Найдено РР с включенным авто-контролем для генерации шаблонов и расписаний: {jobsToGenerate.Count()} шт.");

            if (!jobsToGenerate.Any())
                return;


            jobsToGenerate.ForEach(job =>
            {
                job.JobEkMasks.ToList().ForEach(ek =>
                {
                    job.JobAutoControlInEkStatuses.ToList().ForEach(ekStatus =>
                    {
                        var request = new GeneratorTemplateMq
                        {
                            Action = "create",
                            ApplicationId = job.ApplicationsInWork!.ApplicationId,
                            Ek = ek.Name,
                            WorkId = job.ApplicationsInWork!.WorkId,
                            StatusEk = ekStatus.EkStatusCode,
                            IsActiveTemplate = job.OnTemplateIsActive,
                            IsActiveSchedule = job.OnScheduleIsActive
                        };

                        var msg = JsonSerializer.Serialize(request);

                        var result = mqService.Send(mqSettings.Generator, new[] { msg });

                        if (result.IsSuccess)
                            logger.LogInformation($"Отправлен запрос на генерацию: {msg}");
                        else
                            logger.LogError($"Ошибка при отправке запроса на генерацию: {msg}");
                    });
                });
            });
        }


        /// <summary>
        /// Деактивировать РР
        /// </summary>
        /// <param name="jobAutoControlService"></param>
        /// <param name="mqService"></param>
        /// <returns></returns>
        private async Task DeactivateAsync(IJobAutoControlService jobAutoControlService, IMqService mqService)
        {
            var jobsToDeactivate = await jobAutoControlService.Get()
              .Include(t => t.JobEkMasks)
              .Include(t => t.JobAutoControlInEkStatuses)
              .Where(t => t.Deactivate && t.JobEkMasks.Any() && t.JobAutoControlInEkStatuses.Any())
              .Select(t => t.ApplicationInWorkId)
              .ToListAsync();

            logger.LogInformation($"Найдено РР с включенным авто-контролем для деактивации шаблонов и расписаний: {jobsToDeactivate.Count()} шт.");

            if (!jobsToDeactivate.Any())
                return;

            jobsToDeactivate.ForEach(applicationInWorkId =>
            {
                var request = new TemplateActivatorMq
                {
                    Action = TemplateActivatorActionsEnum.DeactivateAllForAutoControl,
                    ApplicationInWorkId = applicationInWorkId
                };

                var msg = JsonSerializer.Serialize(request);

                var result = mqService.Send(mqSettings.Activator, new[] { msg });

                if (result.IsSuccess)
                    logger.LogInformation($"Отправлен запрос на деактивацию: {msg}");
                else
                    logger.LogError($"Ошибка при отправке запроса на деактивацию: {msg}");
            });
        }


        /// <summary>
        /// Активировать РР
        /// </summary>
        /// <param name="jobAutoControlService"></param>
        /// <param name="mqService"></param>
        /// <returns></returns>
        private async Task ActivateAsync(IJobAutoControlService jobAutoControlService, IMqService mqService)
        {
            var jobsToActivate = await jobAutoControlService.Get()
              .Include(t => t.JobEkMasks)
              .Include(t => t.JobAutoControlInEkStatuses)
              .Where(t => t.Activate && t.JobEkMasks.Any() && t.JobAutoControlInEkStatuses.Any())
              .Select(t => t.ApplicationInWorkId)
              .ToListAsync();

            if (!jobsToActivate.Any())
                return;

            jobsToActivate.ForEach(applicationInWorkId =>
            {
                var request = new TemplateActivatorMq
                {
                    Action = TemplateActivatorActionsEnum.ActivateAllForAutoControl,
                    ApplicationInWorkId = applicationInWorkId
                };

                var msg = JsonSerializer.Serialize(request);

                var result = mqService.Send(mqSettings.Activator, new[] { msg });

                if (result.IsSuccess)
                    logger.LogInformation($"Отправлен запрос на активацию: {msg}");
                else
                    logger.LogError($"Ошибка при отправке запроса на активацию: {msg}");
            });
        }

    }
}