parr_api/PARR.TemplateGeneratorWorker/Worker.cs

using Microsoft.EntityFrameworkCore;
using PARR.BLL.Contracts.Interfaces;
using PARR.BLL.Domain.Mq;
using PARR.BLL.Services.Interfaces;
using PARR.Common.Domain;
using PARR.Constants;
using PARR.DAL.DomainServices.Interfaces;
using PARR.DAL.Models;
using PARR.DAL.Services.Interfaces;
using PARR.DAL.Services.Interfaces.Job;
using PARR.TemplateGeneratorWorker.Services;
using PARR.TemplateGeneratorWorker.Settings;

namespace PARR.TemplateGeneratorWorker
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> logger;
        private readonly IMqSettings mqSettings;
        private readonly IMqService mqService;
        private readonly ITransformService transformService;
        private readonly IValidatorService validatorService;
        private readonly IServiceProvider serviceProvider;

        public Worker(
            ILogger<Worker> logger,
            MqSettings mqSettings,
            IMqService mqService,
            ITransformService transformService,
            IValidatorService validatorService,
            IServiceProvider serviceProvider
            )
        {
            this.logger = logger;
            this.mqSettings = mqSettings;
            this.mqService = mqService;
            this.transformService = transformService;
            this.validatorService = validatorService;
            this.serviceProvider = serviceProvider;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                var isConnected = mqService.InitConsumer(mqSettings, GenerateTemplateAsync);

                if (!isConnected)
                    throw new Exception("Îøèáêà ïðè ïîäêëþ÷åíèè ê RabbitMq");
            }
        }


        public override Task StopAsync(CancellationToken cancellationToken)
        {
            mqService.Dispose();

            return base.StopAsync(cancellationToken);
        }


        private async Task GenerateTemplateAsync(string msg)
        {
            logger.LogInformation($"{this.GetType().Name}. Ïîëó÷èëè çàïðîñ: {msg}");

            var query = transformService.GetModelFromJson<TemplateGeneratorWorkerMq>(msg);
            if (query == null)
                return;

            if (!await validatorService.IsValidAsync(query.JobId, query.UnitId))
            {
                logger.LogError($"Íåêîððåêòíûå ïàðàìåòðû ðåãëàìåíòíîé ðàáîòû {nameof(query.JobId)}: {query.JobId}");
                return;
            }

            using (var scope = serviceProvider.CreateScope())
            {
                var jobService = GetServiceInScope<IJobService>(scope);

                var job = await jobService
                    .Get().AsNoTracking()
                    .FirstOrDefaultAsync(t => t.Id == query.JobId);

                var shortcodesService = GetServiceInScope<IShortcodesService>(scope);
                var templateName = await shortcodesService.ApplyShortcodesAsync(job!.TemplateNameMask!, query.UnitId, query.JobId);

                var template = new Template
                {
                    Id = Guid.NewGuid(),
                    Name = templateName,
                    UnitId = query.UnitId,
                    JobId = query.JobId,
                    IsActiveTemplate = query.IsActiveTemplate ?? false,
                    IsActiveSchedule = query.IsActiveSchedule ?? false,
                    InitiatorComment = query.HistoryInitiator?.InitiatorComment,
                    InitiatorParrComponentId = query.HistoryInitiator?.InitiatorParrComponentId
                };
                var templateService = GetServiceInScope<ITemplateService>(scope);

                if (!await templateService.CreateAsync(template) || !await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Çàïðîñ íà ãåíåðàöèþ ñ òåñòîâîãî øàáëîíà", InitiatorParrComponentId = ParrComponentsEnum.TemplateGenerator }))
                {
                    logger.LogError($"Îøèáêà ïðè ñîçäàíèè øàáëîíà: Name: {template.Name}, {nameof(template.Job)}: {template.JobId}, {nameof(template.Unit)}: {template.UnitId}");
                }
                else
                {
                    logger.LogInformation($"Ñîçäàí øàáëîí: Name: {template.Name}, {nameof(template.Job)}: {template.JobId}, {nameof(template.Unit)}: {template.UnitId}");
                }

            }
        }

        private Service GetServiceInScope<Service>(IServiceScope scope)
        {
            var service = scope.ServiceProvider.GetService<Service>();
            if (service == null)
                throw new Exception($"Íå íàéäåí ñåðâèñ: {nameof(Service)}");

            return service;
        }
    }
}