feat(templateActivator): Методы чтения MQ, обновления состояний шаблонов и расписаний, обновления заданий роботов

PARR.TemplateActivator/IMqTemplateActivator.cs

@@ -0,0 +1,7 @@
+namespace PARR.TemplateActivator;
+
+public interface IMqTemplateActivator
+{
+    void Start();
+    void Stop();
+}

PARR.TemplateActivator/ITemplateActivator.cs

@@ -0,0 +1,8 @@
+using PARR.Constants;
+
+namespace PARR.TemplateActivator;
+
+public interface ITemplateActivator
+{
+    Task ChangeStateAsync(Guid applicationInWorkId, TemplateActivatorActionsEnum action);
+}

PARR.TemplateActivator/MqTemplateActivator.cs

@@ -0,0 +1,71 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using PARR.BLL.Domain.Mq;
+using PARR.BLL.Services.Interfaces;
+using PARR.Constants;
+
+namespace PARR.TemplateActivator;
+
+internal class MqTemplateActivator : IMqTemplateActivator
+{
+    private readonly MqSettings mqSettings;
+    private readonly IMqService mqService;
+    private readonly ILogger<MqTemplateActivator> logger;
+    private readonly ITransformService transformService;
+    private readonly IValidatorService validatorService;
+    private readonly IServiceProvider serviceProvider;
+
+    public MqTemplateActivator(
+        MqSettings mqSettings,
+        IMqService mqService,
+        ILogger<MqTemplateActivator> logger,
+        ITransformService transformService,
+        IValidatorService validatorService,
+        IServiceProvider serviceProvider
+        )
+    {
+        this.mqSettings = mqSettings;
+        this.mqService = mqService;
+        this.logger = logger;
+        this.transformService = transformService;
+        this.validatorService = validatorService;
+        this.serviceProvider = serviceProvider;
+    }
+    public void Start()
+    {
+        var isConnected = mqService.InitConsumer(mqSettings, UpdateTemplateStatusAsync);
+
+        if (!isConnected)
+            throw new Exception("Ошибка при подключении к RabbitMq");
+    }
+
+    private async Task UpdateTemplateStatusAsync(string msg)
+    {
+        logger.LogInformation($"{this.GetType().Name}. Получили запрос: {msg}");
+
+        var query = transformService.GetModelFromJson<TemplateActivatorMq>(msg);
+        if (query == null)
+            return;
+
+        if (!await validatorService.IsValidApplicationInWorkAsync(query.ApplicationInWorkId))
+        {
+            logger.LogError($"{this.GetType().Name}. Некорректные параметры регламентной работы {nameof(query.ApplicationInWorkId)}: {query.ApplicationInWorkId}");
+            return;
+        }
+
+        using (var scope = serviceProvider.CreateScope())
+        {
+            var service = scope.ServiceProvider.GetService<ITemplateActivator>();
+            if (service == null)
+                throw new Exception($"{this.GetType().Name}. Не найден сервис: {nameof(service.GetType)}");
+
+            await service.ChangeStateAsync(query.ApplicationInWorkId, query.Action);
+
+        }
+    }
+
+    public void Stop()
+    {
+        mqService.Dispose();
+    }
+}

PARR.TemplateActivator/Services/IValidatorService.cs

@@ -0,0 +1,8 @@
+using PARR.Constants;
+
+namespace PARR.TemplateActivator;
+
+internal interface IValidatorService
+{
+    Task<bool> IsValidApplicationInWorkAsync(Guid applicationInWorkId);
+}

PARR.TemplateActivator/Services/ValidatorService.cs

@@ -0,0 +1,42 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using PARR.Constants;
+using PARR.DAL.Services.Interfaces;
+
+namespace PARR.TemplateActivator;
+internal class ValidatorService : IValidatorService
+{
+    private readonly IServiceProvider serviceProvider;
+    private readonly ILogger<ValidatorService> logger;
+
+    public ValidatorService(IServiceProvider serviceProvider,
+        ILogger<ValidatorService> logger
+        )
+    {
+        this.serviceProvider = serviceProvider;
+        this.logger = logger;
+    }
+
+    public async Task<bool> IsValidApplicationInWorkAsync(Guid applicationInWorkId)
+    {
+        using (var scope = serviceProvider.CreateScope())
+        {
+            var service = scope.ServiceProvider.GetService<IApplicationsInWorkService>();
+
+            if (service == null)
+                throw new Exception($"Не найден сервис: {nameof(IApplicationsInWorkService)}");
+
+            var appInWork = await service.Get()
+                                            .FirstOrDefaultAsync(t => t.Id == applicationInWorkId);
+
+            if (appInWork == null)
+            {
+                logger.LogError($"Не найдена регалментная работа {nameof(applicationInWorkId)}: {applicationInWorkId}");
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

PARR.TemplateActivator/Settings/MqSettings.cs

@@ -0,0 +1,12 @@
+using PARR.BLL.Contracts.Interfaces;
+
+namespace PARR.TemplateActivator;
+
+internal class MqSettings : IMqSettings
+{
+    public string HostName { get; set; } = string.Empty;
+    public string QueueName { get; set; } = string.Empty;
+    public string User { get; set; } = string.Empty;
+    public string Password { get; set; } = string.Empty;
+}
+

PARR.TemplateActivator/TemplateActivator.cs

@@ -0,0 +1,113 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using PARR.Constants;
+using PARR.DAL.Contracts;
+using PARR.DAL.Models;
+using PARR.DAL.Services.Interfaces;
+
+namespace PARR.TemplateActivator;
+
+internal class TemplateActivator : ITemplateActivator
+{
+    private readonly ILogger<TemplateActivator> logger;
+    private readonly ITemplateService templateService;
+    private readonly IRobotConfigurationService robotConfigurationService;
+
+    public TemplateActivator(
+        ILogger<TemplateActivator> logger,
+        ITemplateService templateService,
+        IRobotConfigurationService robotConfigurationService
+        )
+    {
+        this.logger = logger;
+        this.templateService = templateService;
+        this.robotConfigurationService = robotConfigurationService;
+    }
+    public async Task ChangeStateAsync(Guid applicationInWorkId, TemplateActivatorActionsEnum action)
+    {
+        var query = templateService.Get()
+                           .Include(t => t.RobotConfigurations).ThenInclude(t => t.Robot)
+                           .Where(t => t.ApplicationInWorkId == applicationInWorkId);
+        var changes = 0;
+        switch (action)
+        {
+            case TemplateActivatorActionsEnum.ActivateAllTemplates:
+                query = query.Where(t => !t.IsActiveTemplate);
+                changes = await UpdateTemplateStateAsync(query, true);
+                break;
+            case TemplateActivatorActionsEnum.ActivateTemplatesWithActiveSchedules:
+                query = query.Where(t => !t.IsActiveTemplate && t.IsActiveSchedule);
+                changes = await UpdateTemplateStateAsync(query, true);
+                break;
+            case TemplateActivatorActionsEnum.DeactivateAllTemplates:
+                query = query.Where(t => t.IsActiveTemplate);
+                changes = await UpdateTemplateStateAsync(query, false);
+                break;
+            case TemplateActivatorActionsEnum.DeactivateTemplatesWithDeactivationSchedules:
+                query = query.Where(t => !t.IsActiveTemplate && !t.IsActiveSchedule);
+                changes = await UpdateTemplateStateAsync(query, false);
+                break;
+            case TemplateActivatorActionsEnum.ActivateAllSchedules:
+                query = query.Where(t => !t.IsActiveSchedule);
+                changes = await UpdateScheduleStateAsync(query, true);
+                break;
+            case TemplateActivatorActionsEnum.DeactivateAllSchedules:
+                query = query.Where(t => t.IsActiveSchedule);
+                changes = await UpdateScheduleStateAsync(query, false);
+                break;
+            case TemplateActivatorActionsEnum.ActivateSchedulesWithActiveTemplates:
+                query = query.Where(t => t.IsActiveTemplate && !t.IsActiveSchedule);
+                changes = await UpdateScheduleStateAsync(query, true);
+                break;
+            case TemplateActivatorActionsEnum.DeactivateSchedulesWithDeactivationTemplates:
+                query = query.Where(t => !t.IsActiveTemplate);
+                changes = await UpdateScheduleStateAsync(query, false);
+                break;
+            default:
+                break;
+        }
+
+        if (changes > 0 && !await templateService.CommitAsync())
+            logger.LogError($"{this.GetType} не удалось записать измения состояний шаблонов и расписаний регламентной работы {applicationInWorkId}");
+
+    }
+
+    private async Task<int> UpdateScheduleStateAsync(IQueryable<Template> query, bool newState)
+    {
+        var templates = await query.Select(t => t).ToListAsync();
+
+        if (templates.Any())
+            templates.ForEach(t =>
+            {
+                t.IsActiveSchedule = newState;
+                UpdateRobotConfiguration(RobotsEnum.ScheduleOrder, t);
+            });
+
+
+        templates.ForEach(t => t.IsActiveSchedule = newState);
+
+        return templates.Count;
+    }
+
+    private async Task<int> UpdateTemplateStateAsync(IQueryable<Template> query, bool newState)
+    {
+        var templates = await query.Select(t => t).ToListAsync();
+
+        if (templates.Any())
+            templates.ForEach(t =>
+            {
+                t.IsActiveTemplate = newState;
+                UpdateRobotConfiguration(RobotsEnum.TemplateOrder, t);
+            });
+
+
+        return templates.Count;
+    }
+
+
+    private void UpdateRobotConfiguration(RobotsEnum robotsEnum, Template t)
+    {
+        var config = robotConfigurationService.GetFromTemplateByRobotCode(robotsEnum, ref t);
+        robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, ref config);
+    }
+}

PARR.TemplateActivator/TemplateActivatorInstaller.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using PARR.BLL;
+using PARR.DAL;
+
+namespace PARR.TemplateActivator;
+
+public static class TemplateActivatorInstaller
+{
+
+    public static void InstallTemplateActivatorSerivces(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.InstallBllServices(configuration);
+        services.InstallDalServices(configuration);
+
+        var mqSettings = new MqSettings();
+        configuration.GetSection(nameof(MqSettings)).Bind(mqSettings);
+        services.AddSingleton(mqSettings);
+
+        services.AddTransient<ITemplateActivator, TemplateActivator>();
+        services.AddTransient<IMqTemplateActivator, MqTemplateActivator>();
+        services.AddTransient<IValidatorService, ValidatorService>();
+    }
+}