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.Common.Domain;
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 =>
        //        {
        //            //todo: проверить, нормально ли отрабатывает async в Foreach
        //            job.JobAutoControlInEkStatuses.ToList().ForEach(async 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,
        //                    HistoryInitiator = new HistoryInitiator { InitiatorComment = "Запрос на генерацию с авто-контроля", InitiatorParrComponentId = ParrComponentsEnum.JobAutoControl }
        //                };

        //                var msg = JsonSerializer.Serialize(request);

        //                var result = await mqService.SendAsync(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;

        //    ////todo: проверить, нормально ли отрабатывает async в foreach
        //    //jobsToDeactivate.ForEach(async applicationInWorkId =>
        //    //{
        //    //    var request = new TemplateActivatorMq
        //    //    {
        //    //        Action = TemplateActivatorActionsEnum.DeactivateAllForAutoControl,
        //    //        JobId = applicationInWorkId,
        //    //        HistoryInitiator = new HistoryInitiator { InitiatorComment = "Запрос на деактивацию с авто-контроля", InitiatorParrComponentId = ParrComponentsEnum.JobAutoControl }
        //    //    };

        //    //    var msg = JsonSerializer.Serialize(request);

        //    //    var result = await mqService.SendAsync(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;

        //    //    //todo: проверить, нормально ли отрабатывает async в foreach
        //    //    jobsToActivate.ForEach(async applicationInWorkId =>
        //    //    {
        //    //        var request = new TemplateActivatorMq
        //    //        {
        //    //            Action = TemplateActivatorActionsEnum.ActivateAllForAutoControl,
        //    //            JobId = applicationInWorkId,
        //    //            HistoryInitiator = new HistoryInitiator { InitiatorComment = "Запрос на активацию с авто-контроля", InitiatorParrComponentId = ParrComponentsEnum.JobAutoControl }
        //    //        };

        //    //        var msg = JsonSerializer.Serialize(request);

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

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

    }
}