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;

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

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

        public async Task<bool> ManageStringAsync(string str)
        {
            bool isSuccess = true;
            ////TODO: 
            // тут обязательно нужна проверка, если str не того формата, возникает exception в ParseStringAsync
            if (str == null || str.Trim().Length == 0)
                return false;

            var esppTemplate = parserService.ParseString(str);

            if (esppTemplate == null)
            {
                isSuccess = false;
                logger.LogError($"Не удалось распознать строку({str}) в Template");
            }
            else
            {
                //если шаблон не аквтивен, пропускаем
                //if (!esppTemplate.IsActive)
                //{
                //    return isSuccess;
                //}

                await SyncTemplateAsync(esppTemplate);
                //   var template = await GetTemplateAsync(esppTemplate);
                //var isChanged = false;
                //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.ApplicationsInWork?.ShortDescription})  -----");
                //    return false;
                //}
                //else isChanged = await CheckChangesAsync(esppTemplate, template);
                ////if (isChanged)

                ////var isChanged = await UpdateIfNeedAsync(template);

                //    //if (isChanged)
                //    //{
                //    //    logger.LogInformation($"----- Запись в ЕСПП отличается от Template {esppTemplate.Name}({esppTemplate.ApplicationsInWork?.ShortDescription})  -----");

                //    //    //template.Status = "Updating";
                //    //    template.StatusCode = (int)StatusTemplateEnum.Updating;

                //    //    if (!await templateService.CommitAsync())
                //    //        logger.LogError($"Не удалось обновить запись Template {esppTemplate.Name}({esppTemplate.ApplicationsInWork?.ShortDescription})");
                //    //    else
                //    //        logger.LogInformation($"----- Требуется обновление шаблона в ЕСПП роботом {esppTemplate.Name}({esppTemplate.ApplicationsInWork?.ShortDescription})  -----");
                //    //}
                //    //else
                //    //{
                //    //    //if (template.Status != "Ok")
                //    //    if (template.StatusCode != (int)StatusTemplateEnum.Ok)
                //    //    {
                //    //        template.DateModified = DateTimeOffset.UtcNow;
                //    //        template.StatusCode = (int)StatusTemplateEnum.Ok;

                //    //        if (!await templateService.CommitAsync())
                //    //            logger.LogInformation($"Шаблон в ЕСПП соответствует шаблону в ПАРР {esppTemplate.Name}({esppTemplate.ApplicationsInWork?.ShortDescription}). Установлен статус {StatusTemplateEnum.Ok}");
                //    //    }
                //    //}
            }

            //todo: only true?????
            return isSuccess;
        }

        //private async Task<Template?> GetTemplateAsync(Template esppTemplate)
        //{
        //    using (var scope = serviceProvider.CreateScope())
        //    {
        //        var services = scope.ServiceProvider;

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

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

        //        return await templateService.GetTemplateByNameAsync(esppTemplate.Name);
        //    }
        //}

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

            return;
        }

        private void SetUpdateStatus(Template template)
        {
            template.StatusCode = (int)StatusTemplateEnum.Updating;
        }

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