parr_api/PARR.AIHIT/AIHIT/Syncher.cs

using AutoMapper;
using MailKit.Search;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using MimeKit;
using PARR.AIHIT.Services;
using PARR.AIHIT.Settings;
using PARR.DAL.Contracts;
using PARR.DAL.Extensions;
using PARR.DAL.Models;
using PARR.DAL.Models.AIHIT;
using PARR.DAL.Models.V1;
using PARR.DAL.Services.Interfaces;
using PARR.DAL.Services.Interfaces.AIHIT;
using PARR.DAL.Services.Interfaces.V1;
using PARR.Mail.Services;
using System.Text;
using System.Xml;

namespace PARR.AIHIT
{
    internal class Syncher : ISyncher
    {
        private readonly ILogger<Syncher> logger;
        private readonly IMailService mailService;
        private readonly SyncherSettings syncherSettings;
        private readonly V1_IHostService V1_hostService;
        private readonly V1_IApplicationInHostService V1_appInHostService;
        private readonly V1_IApplicationService V1_appService;
        private readonly IHostService hostService;
        private readonly IMapper mapper;
        private readonly IApplicationService appService;
        private readonly IApplicationTypeService appTypeService;
        private readonly IApplicationInHostService appInHostService;
        private readonly IRawDataEKService rawDataEKService;
        private readonly ISettingService settingService;
        private readonly IAIHITService aihitService;

        public List<ApplicationType> AppTypes { get; private set; } = new List<ApplicationType>();

        public Syncher(
            ILogger<Syncher> logger,
            IMailService mailService,
            SyncherSettings syncherSettings,
            V1_IHostService V1_hostService,
            V1_IApplicationService V1_appService,
            V1_IApplicationTypeService V1_appTypeService,
            V1_IApplicationInHostService V1_appInHostService,
            IHostService hostService,
            IMapper mapper,
            IApplicationService appService,
            IApplicationTypeService appTypeService,
            IApplicationInHostService appInHostService,
            IRawDataEKService rawDataEKService,
            ISettingService settingService,
            IAIHITService aihitService
            )
        {
            this.hostService = hostService;
            this.mapper = mapper;
            this.appService = appService;
            this.appTypeService = appTypeService;
            this.appInHostService = appInHostService;
            this.rawDataEKService = rawDataEKService;
            this.settingService = settingService;
            this.aihitService = aihitService;
            this.logger = logger;
            this.mailService = mailService;
            this.syncherSettings = syncherSettings;
            this.V1_hostService = V1_hostService;
            this.V1_appService = V1_appService;
            this.V1_appInHostService = V1_appInHostService;
        }

        private async Task GetAppTypesAsync()
        {
            AppTypes = await appTypeService.Get().ToListAsync();
        }

        public async Task InvokeAsync()
        {
            await GetAppTypesAsync();


            var messages = await mailService.CheckMailAsync(SearchQuery.NotSeen);
            if (!messages.Any())
            {
                return;
            }
            var filtered = messages.Where(m => syncherSettings.IncludeAddressesArray.Any(i => m.Envelope.From.Mailboxes.FirstOrDefault()?.Address == i)).ToList();
            var lastMessage = filtered.OrderByDescending(f => f.Date).First();
            var attachments = await mailService.GetAttachmentsAsync(lastMessage);

            foreach (var attachment in attachments)
            {
                if (attachment is MessagePart)
                {
                    continue;
                }
                else
                {
                    using var stream = new MemoryStream();
                    ((MimePart)attachment).Content.DecodeTo(stream);
                    if (stream.Position > 0) stream.Position = 0;

                    var fileName = EncodeString(((MimePart)attachment).FileName);
                    logger.LogInformation($" Получен файл {fileName}");
                    if (fileName.Equals("Компонентный состав регионального ЭК.xml"))
                    {
                        XmlDocument doc = new XmlDocument();
                        doc.Load(stream);
                        var vms = doc.GetElementsByTagName("Сведения");
                        //var hosts = await hostService.Get().ToListAsync();
                        foreach (XmlNode vm in vms)
                        {
                            var ip = vm?.Attributes?["IP_АДРЕС"]?.Value.Trim();
                            if (ip == null) continue;
                            var regionalEK = vm!.Attributes!["РЕГИОНАЛЬНЫЙ_ЭК"]!.Value.Trim();
                            var linkEK = vm!.Attributes!["СВЯЗАННЫЙ_ЭК"]!.Value.Trim();
                            if (!linkEK.StartsWith("ВРТ")) continue;

                            // var foundHost = await hostService.GetHostAsync(ip, linkEK, regionalEK);
                            var foundHost = await V1_hostService.GetHostWithAppsAsync(ip, linkEK, regionalEK);
                            var mappedHost = mapper.Map<V1_Host>(vm);

                            var hostApplications = await V1_GetAndFillApplicationsAsync(vm);

                            if (foundHost == null)
                            {
                                // создаем
                                if (!await V1_hostService.CreateAsync(mappedHost) || !await V1_hostService.CommitAsync())
                                {
                                    logger.LogError($"Не удалось создать узел {mappedHost.IP} {mappedHost.RegionalEK}");
                                    continue;
                                }
                                else
                                    logger.LogInformation($"----- Создан Host: {mappedHost.Id}, {mappedHost.LinkEK}  -----");


                                // Синхронизация Applications
                                await V1_SyncApplicationAndHostAsync(foundHost, hostApplications);
                            }
                            else
                            {
                                // обновляем
                                var isChanged = false;
                                if (!foundHost.RegionalEK!.Equals(mappedHost.RegionalEK))
                                {
                                    foundHost.RegionalEK = mappedHost.RegionalEK; isChanged = true;
                                }
                                else if (!foundHost.LinkEK!.Equals(mappedHost.LinkEK))
                                {
                                    foundHost.LinkEK = mappedHost.LinkEK;
                                    isChanged = true;
                                }
                                else if (!foundHost.Status!.Equals(mappedHost.Status))
                                {
                                    foundHost.Status = mappedHost.Status;
                                    isChanged = true;
                                }
                                else if (!foundHost.WorkGroup!.Equals(mappedHost.WorkGroup))
                                {
                                    foundHost.WorkGroup = mappedHost.WorkGroup;
                                    isChanged = true;
                                }
                                else if (!foundHost.Responsible!.Equals(mappedHost.Responsible))
                                {
                                    foundHost.Responsible = mappedHost.Responsible;
                                    isChanged = true;
                                }
                                //else if (!foundHost.OS!.Equals(mappedHost.OS))
                                //{
                                //    foundHost.OS = mappedHost.OS;
                                //    isChanged = true;
                                //}
                                //else if (!foundHost.DB!.Equals(mappedHost.DB))
                                //{
                                //    foundHost.DB = mappedHost.DB;
                                //    isChanged = true;
                                //}
                                //else if (!foundHost.APP!.Equals(mappedHost.APP))
                                //{
                                //    foundHost.APP = mappedHost.APP;
                                //    isChanged = true;
                                //}

                                if (isChanged)
                                {
                                    foundHost.DateModified = DateTimeOffset.UtcNow;
                                    if (!await V1_hostService.CommitAsync())
                                        logger.LogError($"Не удалось обновить узел {mappedHost.IP} {mappedHost.RegionalEK}");
                                    else
                                        logger.LogInformation($"----- Обновлён Host: {mappedHost.Id}, {mappedHost.LinkEK}  -----");
                                }

                                // Синхронизация Applications
                                await V1_SyncApplicationAndHostAsync(foundHost, hostApplications, true);
                            }
                        }
                    }
                    break;
                }
            }

            //прочитано для всех
            foreach (var message in filtered)
            {
                await mailService.SetAsSeenAsync(message);
            }
        }

        public async Task InvokeFromDatabase()
        {
            await GetAppTypesAsync();

            //Получаем зоны ответственности из БД
            var respAreas = await settingService.Get()
                                .Where(ra => ra.Group == AIHTITSettings.RespAreaGroupName)
                                .ToListAsync();
#if !DEBUG
            //Запускаем хранимую процедуру в АИХ ИТ и складываем в таблицу RawDataEKs, предварительно почистив старые данные
            foreach (var respArea in respAreas)
            {
                var eksFromAIHIT = aihitService.GetEKList(respArea.Value)?.ToList();

                if (eksFromAIHIT == null)
                    continue;

                //Удаляем текущие данные по зоне ответственности respArea
                var toDelete = rawDataEKService.Get().Where(rd => rd.ResponseArea == respArea.Value).ToList();
                toDelete.ForEach(d => rawDataEKService.Delete(d));
                if(!await rawDataEKService.CommitAsync())
                {
                    logger.LogError($"Не удалось создать удалить записи в rawDataEK зоны ответственности  {respArea.Name}");
                    continue;
                }

                foreach (var ek in eksFromAIHIT)
                {
                    // создаем
                    var mappedEK = mapper.Map<RawDataEK>(ek);

                    mappedEK.Id = Guid.NewGuid();
                    mappedEK.DateCreated = DateTimeOffset.UtcNow;

                    //if (!await rawDataEKService.CreateAsync(mappedEK) || !await rawDataEKService.CommitAsync())
                    if (!await rawDataEKService.CreateAsync(mappedEK))
                    {
                        logger.LogError($"Не удалось создать запись rawDataEK {mappedEK.ShortName}({mappedEK.IP})");
                        continue;
                    }
                    else
                        logger.LogInformation($"----- Создана запись rawDataEK {mappedEK.ShortName}({mappedEK.IP}), зона ответственности {respArea.Name} -----");
                }
                if (await rawDataEKService.CommitAsync())
                    logger.LogError($"Информация о хостах зоны ответственности {respArea.Name} не записана ");
            }
#endif
            //Разбираем сырые данные

            //Получаем интересующие статусы ЭК
            var statusList = await settingService.Get()
                                    .Where(s => s.Group == AIHTITSettings.StatusGroupName)
                                    .Select(s => s.Value.Trim())
                                    .ToListAsync();

            if (statusList == null || statusList.Count == 0)
                return;

            //Берём только активные шаблоны
            var eks = await rawDataEKService.Get()
                        .Where(e => e.IsActive == "t" && (e.Status != null && statusList.Contains(e.Status.Trim())))
                        .ToListAsync();

            foreach (var ek in eks)
            {
                if (ek.IP == null) 
                    continue;

                var foundHost = await hostService.GetHostWithAppsAsync(ek.IP);
                var mappedHost = mapper.Map<Host>(ek);
                //TODO Валидация по внешним связям

                var hostApplications = await GetAndFillApplicationsAsync(ek);

                if (foundHost == null)
                {
                    // создаем
                    if (!await hostService.CreateAsync(mappedHost) || !await hostService.CommitAsync())
                    {
                        logger.LogError($"Не удалось создать узел {mappedHost.IP}");
                        continue;
                    }
                    else
                        logger.LogInformation($"----- Создан Host: {mappedHost.Id}  -----");


                    // Синхронизация Applications
                    await SyncApplicationAndHostAsync(foundHost, hostApplications);
                }
                else
                {
                    // обновляем
                    var isChanged = false;
                    if (!foundHost.EkStatusCode!.Equals(mappedHost.EkStatusCode))
                    {
                        foundHost.EkStatusCode = mappedHost.EkStatusCode;
                        isChanged = true;
                    }
                    else if (mappedHost.WorkGroup != null && !foundHost.WorkGroup!.Equals(mappedHost.WorkGroup))
                    {
                        foundHost.WorkGroup = mappedHost.WorkGroup;
                        isChanged = true;
                    }

                    if (isChanged)
                    {
                        foundHost.DateModified = DateTimeOffset.UtcNow;
                        if (!await hostService.CommitAsync())
                            logger.LogError($"Не удалось обновить узел {mappedHost.IP}");
                        else
                            logger.LogInformation($"----- Обновлён Host: {mappedHost.Id}  -----");
                    }

                    // Синхронизация Applications
                    await SyncApplicationAndHostAsync(foundHost, hostApplications, true);
                }
            }
        }
        private async Task V1_SyncApplicationAndHostAsync(V1_Host? host, List<V1_Application> hostApplications, bool isUpdateDateModified = false)
        {
            var isUpdated = false;
            if (host == null)
                return;

            logger.LogInformation($"--- Host: {host.Id}, {host.LinkEK}  начало синхронизации приложений ({hostApplications.Count()}) ---");

            foreach (var changedHostApp in hostApplications)
            {
                var exist = host.ApplicationsInHosts.FirstOrDefault(a => a.ApplicationId == changedHostApp.Id);

                if (exist == null)
                {
                    //add
                    logger.LogInformation($"Host: {host.Id}, {host.LinkEK} добавление нового приложения Application {changedHostApp.Name}");

                    var newAppHost = new V1_ApplicationInHost { Id = Guid.NewGuid(), ApplicationId = changedHostApp.Id, HostId = host.Id };
                    if (!await V1_appInHostService.CreateAsync(newAppHost))
                        logger.LogError($"Не удалось создать ApplicationInHost {changedHostApp.Name}, host: {host.Id}, {host.LinkEK}");

                    isUpdated = true;
                }
            }

            foreach (var app in host.ApplicationsInHosts)
            {
                var appToRemove = hostApplications.FirstOrDefault(a => a.Id == app.Id);

                if (appToRemove == null)
                {
                    //todo remove appToRemove
                    var obj = await V1_appInHostService.Get().FirstOrDefaultAsync(t => t.ApplicationId == app.Id && t.HostId == host.Id);
                    if (obj != null)
                    {
                        logger.LogInformation($"Host: {host.Id}, {host.LinkEK} удаление неактуального приложения Application {app.Application?.Name}");
                        V1_appInHostService.Delete(obj);

                        isUpdated = true;
                    }
                }
            }

            if (isUpdated && isUpdateDateModified)
                host.DateModified = DateTimeOffset.UtcNow;

            if (!await appInHostService.CommitAsync())
                logger.LogError($"Не удалось обновить ApplicationInHost для Host: {host.LinkEK}, {host.Id}");

            logger.LogInformation($"=== Host: {host.Id}, {host.LinkEK}  конец синхронизации приложений ===");

        }

        private async Task<List<V1_Application>> V1_GetAndFillApplicationsAsync(XmlNode vm)
        {
            logger.LogInformation($"--- Начало парсинга данных о программном обеспечении(СП, БД, ОС) из Xml документа от АИХ ИТ ---");
            var applications = new List<V1_Application>();

            //TODO GetAppFromXML(vm?.Attributes?["СП"]?.Value).ForEach(async item => await CreateAppIfNotExistAsync(item, ApplicationTypesEnum.APP));
            //GetDBFromXML(vm?.Attributes?["СУБД"]?.Value).ForEach(async item => await CreateAppIfNotExistAsync(item, ApplicationTypesEnum.DB));
            //GetOSFromXML(vm?.Attributes?["ОС"]?.Value).ForEach(async item => await CreateAppIfNotExistAsync(item, ApplicationTypesEnum.OS));
            var appList = GetAppFromXML(vm?.Attributes?["СП"]?.Value);
            foreach (var app in appList)
            {
                var created = await V1_CreateAppIfNotExistAsync(app, ApplicationTypesEnum.APP);
                if (created != null)
                    applications.Add(created);
            }
            var dbList = GetAppFromXML(vm?.Attributes?["СУБД"]?.Value);
            foreach (var db in dbList)
            {
                var created = await V1_CreateAppIfNotExistAsync(db, ApplicationTypesEnum.DB);
                if (created != null)
                    applications.Add(created);
            }
            var osList = GetAppFromXML(vm?.Attributes?["ОС"]?.Value);
            foreach (var os in appList)
            {
                var created = await V1_CreateAppIfNotExistAsync(os, ApplicationTypesEnum.OS);
                if (created != null)
                    applications.Add(created);
            }

            logger.LogInformation($"=== Конец парсинга данных о программном обеспечении(СП, БД, ОС) из Xml документа от АИХ ИТ ===");

            return applications;
        }

        private async Task SyncApplicationAndHostAsync(Host? host, List<Application> hostApplications, bool isUpdateDateModified = false)
        {
            var isUpdated = false;
            if (host == null)
                return;

            logger.LogInformation($"--- Host: {host.Id}, начало синхронизации приложений ({hostApplications.Count()}) ---");

            foreach (var changedHostApp in hostApplications)
            {
                var exist = host.ApplicationsInHosts.FirstOrDefault(a => a.ApplicationId == changedHostApp.Id);

                if (exist == null)
                {
                    //add
                    logger.LogInformation($"Host: {host.Id}, добавление нового приложения Application {changedHostApp.Name}");

                    var newAppHost = new ApplicationInHost { Id = Guid.NewGuid(), ApplicationId = changedHostApp.Id, HostId = host.Id };
                    if (!await appInHostService.CreateAsync(newAppHost))
                        logger.LogError($"Не удалось создать ApplicationInHost {changedHostApp.Name}, host: {host.Id}");

                    isUpdated = true;
                }
            }

            foreach (var app in host.ApplicationsInHosts)
            {
                var appToRemove = hostApplications.FirstOrDefault(a => a.Id == app.Id);

                if (appToRemove == null)
                {
                    //todo remove appToRemove
                    var obj = await appInHostService.Get().FirstOrDefaultAsync(t => t.ApplicationId == app.Id && t.HostId == host.Id);
                    if (obj != null)
                    {
                        logger.LogInformation($"Host: {host.Id}, удаление неактуального приложения Application {app.Application?.Name}");
                        appInHostService.Delete(obj);

                        isUpdated = true;
                    }
                }
            }

            if (isUpdated && isUpdateDateModified)
                host.DateModified = DateTimeOffset.UtcNow;

            if (!await appInHostService.CommitAsync())
                logger.LogError($"Не удалось обновить ApplicationInHost для Host: {host.Id}");

            logger.LogInformation($"=== Host: {host.Id} конец синхронизации приложений ===");

        }
        private async Task<List<Application>> GetAndFillApplicationsAsync(RawDataEK vm)
        {
            logger.LogInformation($"--- Начало парсинга данных о программном обеспечении(СП, БД, ОС) из АИХ ИТ ---");
            var applications = new List<Application>();

            if (vm.APPType != null)
            {
                var appList = vm.APPType.Split(new char[] { ',', ';' }).Distinct().ToList();
                foreach (var app in appList)
                {
                    var created = await CreateAppIfNotExistAsync(app, ApplicationTypesEnum.APP);
                    if (created != null)
                        applications.Add(created);
                }
            }
            if (vm.DBType != null)
            {
                var appList = vm.DBType.Split(new char[] { ',', ';' }).Distinct().ToList();
                foreach (var app in appList)
                {
                    var created = await CreateAppIfNotExistAsync(app, ApplicationTypesEnum.DB);
                    if (created != null)
                        applications.Add(created);
                }
            }
            if (vm.OSType != null)
            {
                var appList = vm.OSType.Split(new char[] { ',', ';' }).Distinct().ToList();
                foreach (var app in appList)
                {
                    var created = await CreateAppIfNotExistAsync(app, ApplicationTypesEnum.OS);
                    if (created != null)
                        applications.Add(created);
                }
            }

            logger.LogInformation($"=== Конец парсинга данных о программном обеспечении(СП, БД, ОС) из АИХ ИТ ===");

            return applications;
        }

        private List<string> GetAppFromXML(string? appField)
        {
            if (string.IsNullOrEmpty(appField))
                return new List<string>();

            var appList = appField.Split(";").Distinct().ToList();
            //appList.ForEach(item => item.Trim());

            return appList;
        }

        private List<string> GetDBFromXML(string? dbField)
        {
            if (string.IsNullOrEmpty(dbField))
                return new List<string>();

            var dbList = dbField.Split(";").Distinct().ToList();
            //dbList.ForEach(item => item.Trim());

            return dbList;
        }

        private List<string> GetOSFromXML(string? osField)
        {
            if (string.IsNullOrEmpty(osField))
                return new List<string>();

            var osList = osField.Split(";").Distinct().ToList();
            //osList.ForEach(item => item.Trim());

            return osList;
        }

        private async Task<V1_Application?> V1_CreateAppIfNotExistAsync(string appName, ApplicationTypesEnum type)//Application application)
        {
            if (string.IsNullOrEmpty(appName) || string.IsNullOrWhiteSpace(appName)) return null;

            var existApp = await V1_appService.GetByNameAsync(appName);
            if (existApp != null)
                return existApp;

            //Создаем
            var appType = GetAppTypeByName(type);
            if (appType == null)
            {
                logger.LogError($"Не удалось создать запись в таблице Applications: {appName}, так как не получил AppType: {type.ToString()}");
                return null;
            }

            var app = new V1_Application
            {
                Id = Guid.NewGuid(),
                Name = appName.Trim(),
                ApplicationTypeId = appType.Id
            };

            if (!await V1_appService.CreateAsync(app) || !await V1_appService.CommitAsync())
                logger.LogError($"Не удалось создать запись в таблице Application: {appName}, {app.ToJson()}");
            else
                logger.LogInformation($"Создана запись а таблице Application: {appName}, {app.ToJson()}");

            return await V1_appService.GetAsync(app.Id);
        }

        private async Task<Application?> CreateAppIfNotExistAsync(string appName, ApplicationTypesEnum type)//Application application)
        {
            if (string.IsNullOrEmpty(appName) || string.IsNullOrWhiteSpace(appName)) return null;

            var existApp = await appService.GetByNameAsync(appName);
            if (existApp != null)
                return existApp;

            //Создаем
            var appType = GetAppTypeByName(type);
            if (appType == null)
            {
                logger.LogError($"Не удалось создать запись в таблице Applications: {appName}, так как не получил AppType: {type.ToString()}");
                return null;
            }

            var app = new Application
            {
                Id = Guid.NewGuid(),
                Name = appName.Trim(),
                ApplicationTypeId = appType.Id
            };

            if (!await appService.CreateAsync(app) || !await appService.CommitAsync())
                logger.LogError($"Не удалось создать запись в таблице Application: {appName}, {app.ToJson()}");
            else
                logger.LogInformation($"Создана запись а таблице Application: {appName}, {app.ToJson()}");

            return await appService.GetAsync(app.Id);
        }

        private ApplicationType? GetAppTypeByName(ApplicationTypesEnum type)
        {
            var existType = AppTypes.FirstOrDefault(t => t.Name == type.ToString());
            if (existType == null)
                logger.LogError($"Не найден AppType: {type}");

            return existType;
        }

        private static string EncodeString(string str)
        {
            byte[] bStr = Encoding.GetEncoding("koi8r").GetBytes(str);
            Encoding encoding = Encoding.GetEncoding("koi8r");
            str = encoding.GetString(bStr, 0, bStr.Length);
            return str;
        }
    }
}