parr_api/PARR.EsppTemplateSync/Services/Manager.cs

using AutoMapper;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using PARR.DAL.Contracts;
using PARR.DAL.Models;
using PARR.DAL.Services.Interfaces;
using PARR.EsppTemplateSync.Domain;
using PARR.EsppTemplateSync.Settings;

namespace PARR.EsppTemplateSync.Services
{
    internal class Manager : IManager
    {
        private readonly ILogger<Manager> logger;
        private readonly IServiceProvider serviceProvider;
        private readonly IParserService parserService;
        private readonly GlobalSettings globalSettings;
        private readonly IMapper mapper;
        private readonly IRobotConfigurationService robotConfigurationService;

        public Manager(
            ILogger<Manager> logger,
            IServiceProvider serviceProvider,
            IParserService parserService,
            GlobalSettings globalSettings,
            IMapper mapper,
            IRobotConfigurationService robotConfigurationService
            )
        {
            this.logger = logger;
            this.serviceProvider = serviceProvider;
            this.parserService = parserService;
            this.globalSettings = globalSettings;
            this.mapper = mapper;
            this.robotConfigurationService = robotConfigurationService;
        }

        public Task<bool> ManageFileAsync(string path)
        {
            throw new NotImplementedException();
        }

        public async Task ManageStringAsync(string str)
        {

            // тут обязательно нужна проверка, если str не того формата, возникает exception в ParseStringAsync
            if (string.IsNullOrEmpty(str))
                return;

            var esppTemplate = parserService.ParseString(str);

            if (esppTemplate == null)
            {
                return;
            }
            else
            {
                //если шаблон не аквтивен, пропускаем
                //if (!esppTemplate.IsActive)
                //{
                //    return isSuccess;
                //}

                await SyncTemplateAsync(esppTemplate);

            }

            return;
        }


        private async Task SyncTemplateAsync(EsppTemplate esppTemplate)
        {
            using (var scope = serviceProvider.CreateScope())
            {
                var services = scope.ServiceProvider;

                var templateService = services.GetService<ITemplateService>();

                if (templateService == null)
                {
                    throw new Exception($"Не найден сервис: {nameof(ITemplateService)}");
                    // return;
                }

                Template? template = await templateService.GetTemplateByNameAsync(esppTemplate.Name);
                //существует в ЕСПП но отсутствует в ПАРР.
                //TODO деактивируем и видимо ещё что-то нужно
                if (template == null)
                {
                    // создает запись-шаблон из ЕСПП в ПАРР. Возможно избыточно так как эталон в ПАРР
                    ////esppTemplate.StatusCode = "Deactivating";
                    ////---
                    //esppTemplate.StatusCode = (int)StatusTemplateEnum.Ok;
                    //esppTemplate.IsActive = false;
                    //if (!await templateService.CreateAsync(esppTemplate) || !await templateService.CommitAsync())
                    //{
                    //    logger.LogError($"Не удалось создать запись Template {esppTemplate.Name}({esppTemplate.ShortDescription})");
                    //}
                    //else
                    //    logger.LogInformation($"----- Создана запись Template {esppTemplate.Name}({esppTemplate.ShortDescription})  -----");
                    //---
                    logger.LogWarning($"----- Найден шаблон ЕСПП незарегистрированный в ПАРР {esppTemplate.Name}({esppTemplate.ShortDescription})  -----");
                    return;
                }
                else
                {
                    var mappedTemplate = mapper.Map<EsppTemplate>(template);
                    if (mappedTemplate == null)
                        return;
                    var isChanged = IsChanged(mappedTemplate, esppTemplate);

                    if (isChanged)
                    {
                        SetUpdateStatus(template);

                        if (!await templateService.CommitAsync())
                        {
                            logger.LogError($"Не удалось изменить запись Template {template.Name}");
                        }
                        else
                            logger.LogInformation($"----- Установлен принудительный статус обновления Template {template.Name}  -----");
                    } //надо ли проверять если не изменился, но был статус Updating не понятно. Доверяем роботу пока, что после окончания работ от точно сообщит 
                }
            }

            return;
        }

        private void SetUpdateStatus(Template template)
        {
            var robotConfig = robotConfigurationService.GetFromTemplateByRobotCode(RobotsEnum.TemplateOrder, ref template);
            robotConfigurationService.ChangeTaskStatus(TaskStatusEnum.Updating, ref robotConfig);
        }

        private bool IsChanged(EsppTemplate template, EsppTemplate esppTemplate)
        {
            foreach (var prop in template.GetType().GetProperties())
            {
                if (prop == null) continue;

                if (globalSettings.IgnoreTemplateFields != null && globalSettings.IgnoreTemplateFields.Contains(prop.Name)) continue;

                var parrValue = template.GetType().GetProperty(prop.Name)?.GetValue(template, null);
                var esppValue = esppTemplate.GetType().GetProperty(prop.Name)?.GetValue(esppTemplate, null);

                if (parrValue == null || esppValue == null)
                    continue;

                if (parrValue!.ToString()!.ToLower() != esppValue!.ToString()!.ToLower())
                    return true;

            }
            return false;
        }
    }
}