parr_api/PARR.TemplateGeneratorWorker/TemplateGenerator.cs


using Microsoft.EntityFrameworkCore;
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.Models.Job;
using PARR.DAL.Models.Unit;
using PARR.DAL.Services.Interfaces;
using PARR.DAL.Services.Interfaces.Job;
using PARR.TemplateGeneratorWorker.Services;

namespace PARR.TemplateGeneratorWorker
{
    internal class TemplateGenerator : ITemplateGenerator
    {
        private readonly ILogger<TemplateGenerator> logger;
        private readonly ITransformService transformService;
        private readonly IValidatorService validatorService;
        private readonly IJobService jobService;
        private readonly IShortcodesService shortcodesService;
        private readonly ITemplateService templateService;

        public TemplateGenerator(
            ILogger<TemplateGenerator> logger,
            ITransformService transformService,
            IValidatorService validatorService,
            IJobService jobService,
            IShortcodesService shortcodesService,
            ITemplateService templateService
            )
        {
            this.logger = logger;
            this.transformService = transformService;
            this.validatorService = validatorService;
            this.jobService = jobService;
            this.shortcodesService = shortcodesService;
            this.templateService = templateService;
        }
        public async Task GenerateTemplateAsync(string msg)
        {
            logger.LogInformation($"Получили запрос: {msg}");

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

            if (query == null)
                return;

            var isTemplateExist = templateService.Get()
                                    .AsNoTracking()
                                    .Any(t => t.JobId == query.JobId && t.UnitId == query.UnitId);

            if (!await validatorService.IsValidAsync(query.JobId, query.UnitId))
            {
                logger.LogError($"Некорректные параметры регламентной работы или Unit {nameof(Job)}: {query.JobId}, {nameof(Unit)}: {query.UnitId}");
                return;
            }

            if (isTemplateExist)
            {
                logger.LogWarning($"Шаблон с JobId={query.JobId} и UnitId={query.UnitId} уже существует");
                return;
            }

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



            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
            };

            if (!await templateService.CreateAsync(template) || !await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Запрос на генерацию с тестового шаблона", InitiatorParrComponentId = ParrComponentsEnum.TemplateTaskGenerator }))
            {
                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}");
            }
        }

    }
}