feat(aihit): AIHITLoadWorker + AIHITSyncWorker

PARR.AIHITLoader/AihitLoader.cs

@@ -0,0 +1,120 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using PARR.AIHITLoader.Models;
+using PARR.AIHITLoader.Services;
+using PARR.AIHITLoader.Settings;
+using PARR.BLL.Domain.Mq;
+using PARR.BLL.Services.Interfaces;
+using System.Globalization;
+using System.Text.Json;
+
+namespace PARR.AIHITLoader
+{
+    internal class AihitLoader : IAihitLoader
+    {
+        private readonly IIntervalService intervalService;
+        private readonly ILogger<AihitLoader> logger;
+        private readonly WorkerSettings workerSettings;
+        private readonly LoaderSettings loaderSettings;
+        private readonly IMqService mqService;
+        private readonly MqSettings mqSettings;
+        private readonly IServiceProvider serviceProvider;
+
+        public AihitLoader(
+            IIntervalService intervalService,
+            ILogger<AihitLoader> logger,
+            WorkerSettings workerSettings,
+            LoaderSettings loaderSettings,
+            IMqService mqService,
+            MqSettings mqSettings,
+            IServiceProvider serviceProvider
+            )
+        {
+            this.intervalService = intervalService;
+            this.logger = logger;
+            this.workerSettings = workerSettings;
+            this.loaderSettings = loaderSettings;
+            this.mqService = mqService;
+            this.mqSettings = mqSettings;
+            this.serviceProvider = serviceProvider;
+        }
+
+        public async Task StartAsync()
+        {
+            logger.LogInformation("Запуск сервиса загрузки данных из АИХИТ.");
+
+            await intervalService.IntervalInitAsync(UploadDataAsync, workerSettings.RepeatEvery);
+        }
+
+        private async Task UploadDataAsync()
+        {
+            foreach (var respArea in loaderSettings.ResponseAreas)
+            {
+                var aihitData = GetDataFromAihit(respArea);
+
+                if (aihitData == null) return;
+
+                var filteredAIhitData = FilterData(aihitData);
+
+                var preparedData = filteredAIhitData.Select(d => JsonSerializer.Serialize(MapAihitToDomain(d)));
+
+                var parts = preparedData.Count() / loaderSettings.PackageSize;
+                parts++;
+
+                for (var i = 0; i < parts; i++)
+                {
+                    var batch = preparedData.Skip(i * loaderSettings.PackageSize).Take(loaderSettings.PackageSize).ToList();
+                    var sendResult = mqService.Send(mqSettings, batch.ToArray());
+                    if (sendResult.IsSuccess)
+                    {
+                        logger.LogInformation($"Данные переданы в RabbitMQ: {batch.Count()}");
+                        logger.LogDebug($"Список ЭК переданных в RabbitMQ: {string.Join(", ", batch)}");
+                    }
+                    else
+                        logger.LogError($"Ошибка при передаче нарядов в Rabbit, не переданные сообщения: {string.Join(", ", sendResult.NotSendMessages)}");
+                }
+
+            }
+            await Task.CompletedTask;
+        }
+
+        /// <summary>
+        /// Фильтруем входные данные из АИХ ИТ по необходимости. На первом этапе берём только эк по максе ВРТ-*
+        /// </summary>
+        /// <param name="aihitData"></param>
+        /// <returns></returns>
+        private List<EK> FilterData(List<EK> aihitData)
+        {
+            var vrt = aihitData.Where(ek => ek.EKFindCode!.StartsWith("ВРТ", true, CultureInfo.GetCultureInfo("ru-RU"))).ToList();
+            return vrt.Where(vrt => vrt.IP != null).ToList();
+        }
+
+        private List<EK>? GetDataFromAihit(string respArea)
+        {
+            using (var scope = serviceProvider.CreateScope())
+            {
+                var aihitService = scope.ServiceProvider.GetService<IAIHITService>();
+                if (aihitService == null)
+                    throw new Exception("Не смог получить серивс IAIHITService, scope.ServiceProvider.GetService<IAIHITService>()");
+
+                return aihitService.GetEKList(respArea);
+            }
+        }
+
+
+        private AihitDataMq MapAihitToDomain(EK ek)
+        {
+            return new AihitDataMq
+            {
+                EK = ek.EKFindCode!,
+                IP = ek.IP,
+                APPType = ek.APPType,
+                DBType = ek.DBType,
+                OSType = ek.OSType,
+                WorkGroup = ek.WorkGroup,
+                Status = (ek.Status == "00-ГВЦ")? "99-ГВЦ": ek.Status!,
+                ResponseArea = ek.ResponseArea!
+            };
+        }
+    }
+}

PARR.AIHITLoader/AihitLoaderInstaller.cs

@@ -1,5 +1,9 @@
-using Microsoft.Extensions.Configuration;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using PARR.AIHITLoader.Context;
+using PARR.AIHITLoader.Services;
+using PARR.AIHITLoader.Settings;
 using PARR.BLL;
 
 namespace PARR.AIHITLoader
@@ -10,6 +14,27 @@ namespace PARR.AIHITLoader
         {
             services.InstallBllServices(configuration);
 
+            var settings = new WorkerSettings();
+            configuration.GetSection(nameof(WorkerSettings)).Bind(settings);
+            services.AddSingleton(settings);
+
+            var loaderSettings = new LoaderSettings();
+            configuration.GetSection(nameof(LoaderSettings)).Bind(loaderSettings);
+            services.AddSingleton(loaderSettings);
+
+            var mqSettings = new MqSettings();
+            configuration.GetSection(nameof(MqSettings)).Bind(mqSettings);
+            services.AddSingleton(mqSettings);
+
+            services.AddDbContext<AIHITContext>(options =>
+                options.UseSqlServer(
+                configuration.GetConnectionString("AihitConnection")
+                , sqlServerOptions => sqlServerOptions.CommandTimeout(1800)
+            ));
+
+            services.AddTransient<IAihitLoader, AihitLoader>();
+            services.AddTransient<IAIHITService, AIHITService>();
+
             //todo: config e.t.c
         }
     }

PARR.AIHITLoader/Context/AIHITContext.cs

@@ -0,0 +1,14 @@
+using Microsoft.EntityFrameworkCore;
+using PARR.AIHITLoader.Models;
+
+namespace PARR.AIHITLoader.Context
+{
+    internal class AIHITContext : DbContext
+    {
+        public AIHITContext(DbContextOptions<AIHITContext> options) : base(options) { }
+
+
+
+        public DbSet<EK> EKs { get; set; }
+    }
+}

PARR.AIHITLoader/IAihitLoader.cs

@@ -0,0 +1,7 @@
+namespace PARR.AIHITLoader
+{
+    public interface IAihitLoader
+    {
+        Task StartAsync();
+    }
+}

PARR.AIHITLoader/Models/EK.cs

@@ -0,0 +1,100 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace PARR.AIHITLoader.Models
+{
+    public class EK
+    {
+        [Column("IP_АДРЕС")]
+        public string? IP { get; set; }
+        [Column("МЕТКА")]
+        public string? Metka { get; set; }
+        [Column("АКТИВЕН")]
+        public string? IsActive { get; set; }
+        [Column("ВАЖНЫЙ_ЭК")]
+        public string? IsImportant { get; set; }
+        [Column("ВРЕМЯ_СОЗДАНИЯ")]
+        public DateTime? CreateTime { get; set; }
+        [Column("ДОПОЛНИТЕЛЬНАЯ_ИНФОРМАЦИЯ")]
+        public string? AdditionalInfo { get; set; }
+        [Column("ЗОНА_ОТВЕТСТВЕННОСТИ")]
+        public string? ResponseArea { get; set; }
+        [Column("КАТЕГОРИЯ_ЭК")]
+        public string? EKCategory { get; set; }
+        [Column("КОД_ПОИСКА_ЭК")]
+        public string? EKFindCode { get; set; }
+        [Column("КОД_ПРОДУКТА")]
+        public string? ProductCode { get; set; }
+        [Column("КОД_УСЛУГИ")]
+        public string? ServiceCode { get; set; }
+        [Column("КРАТКОЕ_НАИМЕНОВАНИЕ")]
+        public string? ShortName { get; set; }
+        [Column("ОТВЕТСТВЕННЫЙ_ЗА_ЭК")]
+        public string? ResponsibleByEK { get; set; }
+        [Column("ПЛАНОВОЕ_ВРЕМЯ_ВОССТАНОВЛЕНИЯ")]
+        public DateTime? PlannedTimeToRepair { get; set; }
+        [Column("ПОДКАТЕГОРИЯ_ЭК")]
+        public string? EKSubCategory { get; set; }
+        [Column("ПОЛНОЕ_НАИМЕНОВАНИЕ")]
+        public string? FullName { get; set; }
+        [Column("ПРЕДПИСАНИЕ")]
+        public string? Prescription { get; set; }
+        [Column("ПРЕДПРИЯТИЕ")]
+        public string? Company { get; set; }
+        [Column("РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК")]
+        public string? WorkGroup { get; set; }
+        [Column("РАСПОЛОЖЕНИЕ")]
+        public string? Location { get; set; }
+        [Column("РЕВИЗОР_ЭК")]
+        public string? EKRevizor { get; set; }
+        [Column("РЕГИСТРАТОР_ЭК")]
+        public string? EKRegister { get; set; }
+        [Column("СЕТЕВОЕ_ИМЯ")]
+        public string? NetworkName { get; set; }
+        [Column("СТАТУС")]
+        public string? Status { get; set; }
+        [Column("ТИП_ЭК")]
+        public string? EKType { get; set; }
+        [Column("ФАКТИЧЕСКОЕ_ЗАВЕРШЕНИЕ_ЭКСПЛУАТАЦИИ")]
+        public DateTime? EndExplotationDate { get; set; }
+        [Column("ФАКТИЧЕСКОЕ_НАЧАЛО_ЭКСПЛУАТАЦИИ")]
+        public DateTime? StartExplotationDate { get; set; }
+        [Column("ЦЕЛЕВОЕ_ВРЕМЯ_ВОССТАНОВЛЕНИЯ")]
+        public string? TargetRepairTime { get; set; }
+        [Column("SYSMODTIME")]
+        public DateTime? SysModTime { get; set; }
+        [Column("SYSMODUSER")]
+        public string? SysModUser { get; set; }
+        [Column("НОВЫЙ_КОД_ПОИСКА")]
+        public string? NewEKFindCode { get; set; }
+        [Column("СТАРЫЙ_КОД_ПОИСКА")]
+        public string? OldEKFindCode { get; set; }
+        [Column("НАПРАВЛЕНИЕ_ЦТС_ЦК")]
+        public string? CTSDirection { get; set; }
+        [Key]
+        [Column("ID")]
+        public int? AIHID { get; set; }
+        [Column("недостоверные_данные")]
+        public char? IsUnreliableData { get; set; }
+        [Column("РГ_смены")]
+        public string? ShiftWorkGroup { get; set; }
+        [Column("Клиентское_ПО")]
+        public string? ClientSoftware { get; set; }
+        [Column("Клиентская_ОС")]
+        public string? ClientOS { get; set; }
+        [Column("Тип СУБД")]
+        public string? DBType { get; set; }
+        [Column("Тип сервера приложений")]
+        public string? APPType { get; set; }
+        [Column("Тип сервера ЦК БС")]
+        public string? CKBSServerType { get; set; }
+        [Column("Тип сервера ИБ")]
+        public string? IBServerType { get; set; }
+        [Column("Тип сервера инфраструктуры")]
+        public string? InfrastructureServerType { get; set; }
+        [Column("Тип сервера мониторинга")]
+        public string? MonitoringServerType { get; set; }
+        [Column("ОС")]
+        public string? OSType { get; set; }
+    }
+}

PARR.AIHITLoader/PARR.AIHITLoader.csproj

@@ -6,6 +6,10 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.9" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\PARR.BLL\PARR.BLL.csproj" />
   </ItemGroup>

PARR.AIHITLoader/Services/AIHITService.cs

@@ -0,0 +1,42 @@
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using PARR.AIHITLoader.Context;
+using PARR.AIHITLoader.Models;
+
+namespace PARR.AIHITLoader.Services
+{
+    internal class AIHITService : IAIHITService
+    {
+        private readonly AIHITContext context;
+        private readonly ILogger<AIHITService> logger;
+
+        public AIHITService(AIHITContext context, ILogger<AIHITService> logger)
+        {
+            this.context = context;
+            this.logger = logger;
+        }
+        public List<EK>? GetEKList(string respArea)
+        {
+            var parameters = new List<SqlParameter>() { new SqlParameter("@зо", respArea) };
+
+            try
+            {
+                var result = context.Set<EK>().FromSqlRaw($"EXEC mao2.dbo.sp_IPP_PARR_PTK_get_EK @зо", parameters.ToArray()).ToList();
+
+                if (result == null || !result.Any())
+                {
+                    logger.LogWarning($"Процедура sp_IPP_PARR_PTK_get_EK вернула пустой список ЭК");
+                }
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, $"Ошибка при выполнении ХП sp_IPP_PARR_PTK_get_EK({respArea})");
+            }
+
+            return null;
+        }
+    }
+}

PARR.AIHITLoader/Services/IAIHITService.cs

@@ -0,0 +1,9 @@
+using PARR.AIHITLoader.Models;
+
+namespace PARR.AIHITLoader.Services
+{
+    internal interface IAIHITService
+    {
+        List<EK>? GetEKList(string respArea);
+    }
+}

PARR.AIHITLoader/Settings/LoaderSettings.cs

@@ -0,0 +1,8 @@
+namespace PARR.AIHITLoader.Settings
+{
+    internal class LoaderSettings
+    {
+        public List<string> ResponseAreas { get; set; } = new List<string>();
+        public int PackageSize { get; set; } = 100;
+    }
+}

PARR.AIHITLoader/Settings/MqSettings.cs

@@ -0,0 +1,12 @@
+using PARR.BLL.Contracts.Interfaces;
+
+namespace PARR.AIHITLoader.Settings
+{
+    internal class MqSettings : IMqSettings
+    {
+        public string HostName { get; set; } = string.Empty;
+        public string QueueName { get; set; } = string.Empty;
+        public string User { get; set; } = string.Empty;
+        public string Password { get; set; } = string.Empty;
+    }
+}

PARR.AIHITLoader/Settings/WorkerSettings.cs

@@ -0,0 +1,7 @@
+namespace PARR.AIHITLoader.Settings
+{
+    internal class WorkerSettings
+    {
+        public TimeSpan RepeatEvery { get; set; }
+    }
+}

PARR.AIHITLoaderWorker/Worker.cs

@@ -1,21 +1,21 @@
+using PARR.AIHITLoader;
+
 namespace PARR.AIHITLoaderWorker
 {
     public class Worker : BackgroundService
     {
         private readonly ILogger<Worker> _logger;
+        private readonly IAihitLoader aihitLoader;
 
-        public Worker(ILogger<Worker> logger)
+        public Worker(ILogger<Worker> logger, IAihitLoader aihitLoader)
         {
             _logger = logger;
+            this.aihitLoader = aihitLoader;
         }
 
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
-            while (!stoppingToken.IsCancellationRequested)
+            await aihitLoader.StartAsync();
-            {
-                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
-                await Task.Delay(1000, stoppingToken);
-            }
         }
     }
 }

PARR.AIHITLoaderWorker/appsettings.json

@@ -1,8 +1,43 @@
 {
+  "ConnectionStrings": {
+    "AihitConnection": "Data Source=10.248.19.97; Initial Catalog=mao2;User ID=awhit-ipp-parr;pwd=ET3h$9y1LH#D;TrustServerCertificate=true;"
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Information",
       "Microsoft.Hosting.Lifetime": "Information"
     }
+  },
+  "WorkerSettings": {
+    "RepeatEvery": "12:00:00"
+  },
+  "MqSettings": {
+    "HostName": "10.99.253.216",
+    "QueueName": "parr-aihit-data",
+    "User": "aihit_loader",
+    "Password": "123fsdf&78sd9534dsfD"
+  },
+  "LoaderSettings": {
+    "ResponseAreas": [
+      "96-ДВС",
+      "10-КЛГ",
+      "58-ЮВСТ",
+      "01-ОКТ",
+      "61-ПРИВ",
+      "17-МСК",
+      "28-СЕВ",
+      "92-ВСИБ",
+      "00-ГВЦ",
+      "88-КРАСН",
+      "24-ГОР",
+      "80-ЮУР",
+      "51-СКВ",
+      "76-СВРД",
+      "63-КБШ",
+      "83-ЗСИБ",
+      "94-ЗАБ"
+    ],
+    "PackageSize": 100
   }
+
 }

PARR.AIHITSyncer/AihitSyncer.cs

@@ -0,0 +1,336 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using PARR.AIHITSyncer.Settings;
+using PARR.BLL.Domain.Mq;
+using PARR.BLL.Services.Interfaces;
+using PARR.DAL.Contracts;
+using PARR.DAL.Extensions;
+using PARR.DAL.Models;
+using PARR.DAL.Services.Interfaces;
+using System.Text.RegularExpressions;
+
+namespace PARR.AIHITSyncer
+{
+    internal class AihitSyncer : IAihitSyncer
+    {
+        private readonly ILogger<AihitSyncer> logger;
+        private readonly WorkerSettings workerSettings;
+        private readonly IMqService mqService;
+        private readonly MqSettings mqSettings;
+        private readonly ITransformService transformService;
+        private readonly IServiceProvider serviceProvider;
+
+        public List<ApplicationType> AppTypes { get; private set; } = new List<ApplicationType>();
+        public AihitSyncer(
+            ILogger<AihitSyncer> logger,
+            WorkerSettings workerSettings,
+            IMqService mqService,
+            MqSettings mqSettings,
+            ITransformService transformService,
+            IServiceProvider serviceProvider
+            )
+        {
+            this.logger = logger;
+            this.workerSettings = workerSettings;
+            this.mqService = mqService;
+            this.mqSettings = mqSettings;
+            this.transformService = transformService;
+            this.serviceProvider = serviceProvider;
+        }
+        private async Task GetAppTypesAsync()
+        {
+            if (AppTypes == null || AppTypes.Count == 0)
+                using (var scope = serviceProvider.CreateScope())
+                {
+                    var appTypesService = scope.ServiceProvider.GetService<IApplicationTypeService>();
+                    if (appTypesService == null)
+                        throw new Exception("Не смог получить серивс IApplicationTypeService, scope.ServiceProvider.GetService<IApplicationTypeService>()");
+
+                    AppTypes = await appTypesService.Get().ToListAsync();
+                }
+
+        }
+        public void Start()
+        {
+            logger.LogInformation("Запуск сервиса синхронизации данных из АИХИТ и ПАРР.");
+            var isConnected = mqService.InitConsumer(mqSettings, SyncDataAsync);
+
+            if (!isConnected)
+                throw new Exception("Ошибка при подключении к RabbitMq");
+        }
+        public void Stop()
+        {
+            mqService.Dispose();
+        }
+
+        private async Task SyncDataAsync(string msg)
+        {
+            var objFromQuery = transformService.GetModelFromJson<AihitDataMq>(msg);
+            if (objFromQuery == null)
+                return;
+
+            using (var scope = serviceProvider.CreateScope())
+            {
+                var hostService = scope.ServiceProvider.GetService<IHostService>();
+                if (hostService == null)
+                    throw new Exception("Не смог получить серивс IHostService, scope.ServiceProvider.GetService<IHostService>()");
+
+                await SyncHostToScopeAsync(hostService, objFromQuery);
+
+                await GetAppTypesAsync();
+            }
+
+            logger.LogDebug($"Закончил работу с сообщением: {msg}");
+            //await Task.CompletedTask;
+        }
+
+        private async Task SyncHostToScopeAsync(IHostService hostService, AihitDataMq objFromQuery)
+        {
+            //ищем существующий хост в БД
+            var host = await hostService.GetHostWithAppsAsync(objFromQuery.IP);
+            var isNew = false;
+            //если не нашли - создаём
+            if (host == null)
+            {
+                isNew = true;
+                host = await CreateHostAsync(hostService, objFromQuery);
+            }
+            else
+            {
+                logger.LogDebug($"Найден хост в БД: {host!.Ek}({host.IP})");
+                //проверям и обновляем поля
+                await SyncHostFieldsAsync(hostService, host, objFromQuery);
+            }
+
+            //получаем лист ПО из объекта
+            var appsInObj = await GetAppInObjectAsync(host, objFromQuery);
+
+            await SyncApplicationAndHostAsync(host, appsInObj, !isNew);
+        }
+
+        private async Task<List<Application>> GetAppInObjectAsync(Host? host, AihitDataMq objFromQuery)
+        {
+            var applications = new List<Application>();
+
+            if (objFromQuery.APPType != null)
+            {
+                var appList = objFromQuery.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 (objFromQuery.DBType != null)
+            {
+                var appList = objFromQuery.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 (objFromQuery.OSType != null)
+            {
+                var appList = objFromQuery.OSType.Split(new char[] { ',', ';' }).Distinct().ToList();
+                foreach (var app in appList)
+                {
+                    var created = await CreateAppIfNotExistAsync(app, ApplicationTypesEnum.OS);
+                    if (created != null)
+                        applications.Add(created);
+                }
+            }
+            return applications;
+        }
+
+        private async Task SyncHostFieldsAsync(IHostService hostService, Host host, AihitDataMq objFromQuery)
+        {
+            var isChanged = false;
+            if (host.IP != objFromQuery.IP)
+            {
+                host.IP = objFromQuery.IP;
+                isChanged = true;
+            }
+            if (host.EkStatusCode != ResolveCode(objFromQuery.Status))
+            {
+                host.EkStatusCode = ResolveCode(objFromQuery.Status);
+                isChanged = true;
+            }
+            if (objFromQuery.WorkGroup != null && (host.WorkGroup == null || !host.WorkGroup!.Equals(objFromQuery.WorkGroup)))
+            {
+                host.WorkGroup = objFromQuery.WorkGroup;
+                isChanged = true;
+            }
+            if (host.ResponseAreaCode != ((ResolveCode(objFromQuery.ResponseArea) == 0) ? 99 : ResolveCode(objFromQuery.ResponseArea)))
+            {//TODO Возможно проще выгружать с помощью INCLUDE зону ответственности и сравнивать string
+                host.ResponseAreaCode = ((ResolveCode(objFromQuery.ResponseArea) == 0) ? 99 : ResolveCode(objFromQuery.ResponseArea));
+                isChanged = true;
+            }
+            if (isChanged)
+            {
+                host.DateModified = DateTimeOffset.UtcNow;
+                if (!await hostService.CommitAsync())
+                    logger.LogError($"Не удалось обновить узел {host.Ek}({host.IP})");
+                else
+                    logger.LogInformation($"Обновлён Host: {host.Ek}({host.Id})");
+            }
+        }
+
+        private async Task<Host?> CreateHostAsync(IHostService hostService, AihitDataMq objFromQuery)
+        {
+            var id = Guid.NewGuid();
+            var host = new Host
+            {
+                Id = id,
+                Ek = objFromQuery.EK,
+                IP = objFromQuery.IP,
+                EkStatusCode = ResolveCode(objFromQuery.Status),
+                WorkGroup = objFromQuery.WorkGroup,
+                ResponseAreaCode = ResolveCode(objFromQuery.ResponseArea)
+            };
+
+            if (!await hostService.CreateAsync(host) || !await hostService.CommitAsync())
+                logger.LogError($"Не удалось создать узел {host.Ek}({host.IP})");
+            else
+                logger.LogInformation($"----- Создан узел: {host.Id}  -----");
+
+
+            return await hostService.GetHostWithAppsAsync(host.IP);
+        }
+
+
+        /// <summary>
+        /// Возвращает первую цифру из строки, котроая является кодом статуса или зоны ответственности для ЭК
+        /// </summary>
+        /// <param name="field"></param>
+        /// <returns></returns>
+        private int ResolveCode(string field)
+        {
+            var pattern = "\\d+";
+            var regex = new Regex(pattern);
+
+            int.TryParse(regex.Match(field).Value, out int result);
+
+            return result;
+        }
+
+        private async Task<Application?> CreateAppIfNotExistAsync(string appName, ApplicationTypesEnum type)
+        {
+            if (string.IsNullOrEmpty(appName) || string.IsNullOrWhiteSpace(appName)) return null;
+
+
+            using (var scope = serviceProvider.CreateScope())
+            {
+                var appService = scope.ServiceProvider.GetService<IApplicationService>();
+                if (appService == null)
+                    throw new Exception("Не смог получить серивс IApplicationService, scope.ServiceProvider.GetService<IApplicationService>()");
+
+                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);
+            }
+        }
+
+        /// <summary>
+        /// Метод синхронизации 
+        /// </summary>
+        /// <param name="host">Хост</param>
+        /// <param name="hostApplications">Список программного обеспечения</param>
+        /// <param name="isUpdateDateModified">Признак обновления поля DateModified</param>
+        /// <returns></returns>
+        private async Task SyncApplicationAndHostAsync(Host? host, List<Application> appsInObject, bool isUpdateDateModified = false)
+        {
+            var isUpdated = false;
+            if (host == null)
+                return;
+
+            logger.LogDebug($"Host: {host.Ek}({host.IP}), начало синхронизации приложений ({appsInObject.Count()}) ");
+            using (var scope = serviceProvider.CreateScope())
+            {
+                var appInHostService = scope.ServiceProvider.GetService<IApplicationInHostService>();
+                if (appInHostService == null)
+                    throw new Exception("Не смог получить серивс IApplicationInHostService, scope.ServiceProvider.GetService<IApplicationInHostService>()");
+
+
+                foreach (var appInObject in appsInObject)
+                {
+                    var exist = host.ApplicationsInHosts.FirstOrDefault(a => a.ApplicationId == appInObject.Id);
+
+                    if (exist == null)
+                    {
+                        //add
+                        logger.LogInformation($"Host: {host.Ek}({host.IP}), добавление нового приложения Application {appInObject.Name}");
+
+                        var newAppHost = new ApplicationInHost { Id = Guid.NewGuid(), ApplicationId = appInObject.Id, HostId = host.Id };
+                        if (!await appInHostService.CreateAsync(newAppHost))
+                            logger.LogError($"Не удалось создать ApplicationInHost {appInObject.Name}, host: {host.Ek}({host.IP})");
+
+                        isUpdated = true;
+                    }
+                }
+
+                foreach (var appInHost in host.ApplicationsInHosts)
+                {
+                    var appToRemove = appsInObject.FirstOrDefault(a => a.Id == appInHost.ApplicationId);
+
+                    if (appToRemove == null)
+                    {
+                        //todo remove appToRemove
+                        var obj = await appInHostService.Get().FirstOrDefaultAsync(t => t.ApplicationId == appInHost.ApplicationId && t.HostId == host.Id);
+                        if (obj != null)
+                        {
+                            logger.LogInformation($"Host: {host.Ek}({host.IP}), удаление неактуального приложения Application {appInHost.Application?.Name}");
+                            appInHostService.Delete(obj);
+
+                            if (!await appInHostService.CommitAsync())
+                                logger.LogError($"Не удалось удалить Application {appInHost.Application?.Name} узла {host.Ek}({host.IP})");
+
+                            isUpdated = true;
+                        }
+                    }
+                }
+
+                if (isUpdated && isUpdateDateModified)
+                    host.DateModified = DateTimeOffset.UtcNow;
+
+                if (!await appInHostService.CommitAsync())
+                    logger.LogError($"Не удалось обновить ApplicationInHost для Host: {host.Ek}({host.IP})");
+            }
+            logger.LogDebug($"Host: {host.Ek}({host.IP} конец синхронизации приложений");
+
+        }
+        private ApplicationType? GetAppTypeByName(ApplicationTypesEnum type)
+        {
+            var existType = AppTypes.FirstOrDefault(t => t.Name == type.ToString());
+            if (existType == null)
+                logger.LogError($"Не найден AppType: {type}");
+
+            return existType;
+        }
+    }
+}

PARR.AIHITSyncer/AihitSyncerInstaller.cs

@@ -1,6 +1,8 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using PARR.AIHITSyncer.Settings;
 using PARR.BLL;
+using PARR.DAL;
 
 namespace PARR.AIHITSyncer
 {
@@ -9,8 +11,17 @@ namespace PARR.AIHITSyncer
         public static void InstallAihitSyncerServices(this IServiceCollection services, IConfiguration configuration)
         {
             services.InstallBllServices(configuration);
+            services.InstallDalServices(configuration);
 
-            //todo: config e.t.c
+            var settings = new WorkerSettings();
+            configuration.GetSection(nameof(WorkerSettings)).Bind(settings);
+            services.AddSingleton(settings);
+
+            var mqSettings = new MqSettings();
+            configuration.GetSection(nameof(MqSettings)).Bind(mqSettings);
+            services.AddSingleton(mqSettings);
+
+            services.AddTransient<IAihitSyncer, AihitSyncer>();
         }
     }
 }

PARR.AIHITSyncer/IAihitSyncer.cs

@@ -0,0 +1,8 @@
+namespace PARR.AIHITSyncer
+{
+    public interface IAihitSyncer
+    {
+        void Start();
+        void Stop();
+    }
+}

PARR.AIHITSyncer/Settings/MqSettings.cs

@@ -0,0 +1,12 @@
+using PARR.BLL.Contracts.Interfaces;
+
+namespace PARR.AIHITSyncer.Settings
+{
+    internal class MqSettings : IMqSettings
+    {
+        public string HostName { get; set; } = string.Empty;
+        public string QueueName { get; set; } = string.Empty;
+        public string User { get; set; } = string.Empty;
+        public string Password { get; set; } = string.Empty;
+    }
+}

PARR.AIHITSyncer/Settings/WorkerSettings.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PARR.AIHITSyncer.Settings
+{
+    internal class WorkerSettings
+    {
+        public TimeSpan RepeatEvery { get; set; }
+    }
+}

PARR.AIHITSyncerWorker/Worker.cs

@@ -1,21 +1,28 @@
+using PARR.AIHITSyncer;
+
 namespace PARR.AIHITSyncerWorker
 {
     public class Worker : BackgroundService
     {
         private readonly ILogger<Worker> _logger;
+        private readonly IAihitSyncer aihitSyncer;
 
-        public Worker(ILogger<Worker> logger)
+        public Worker(ILogger<Worker> logger, IAihitSyncer aihitSyncer)
         {
             _logger = logger;
+            this.aihitSyncer = aihitSyncer;
         }
 
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
-            while (!stoppingToken.IsCancellationRequested)
+            aihitSyncer.Start();
+        }
+
+        public override Task StopAsync(CancellationToken cancellationToken)
         {
-                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
+            aihitSyncer.Stop();
-                await Task.Delay(1000, stoppingToken);
+
-            }
+            return base.StopAsync(cancellationToken);
         }
     }
 }

PARR.AIHITSyncerWorker/appsettings.json

@@ -1,8 +1,38 @@
 {
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=10.99.253.184;Database=parr;User Id=app_parr; Password=PosdfkhT&)%sdfligL&%5546;"
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Information",
       "Microsoft.Hosting.Lifetime": "Information"
     }
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Debug",
+      "Override": {
+        "Microsoft": "Warning",
+        "Microsoft.Hosting.Lifetime": "Debug"
+      }
+    },
+    "WriteTo": [
+      {
+        "Name": "File",
+        "Args": {
+          "path": "log/log-.txt",
+          "rollingInterval": "Day"
+        }
+      }
+    ]
+  },
+  "WorkerSettings": {
+    "RepeatEvery": "00:10:00"
+  },
+  "MqSettings": {
+    "HostName": "10.99.253.216",
+    "QueueName": "parr-aihit-data",
+    "User": "aihit_syncer",
+    "Password": "afsdgDGjhfiU76496as42!@"
   }
 }

PARR.BLL/Domain/Mq/AihitDataMq.cs

@@ -3,8 +3,15 @@
     /// <summary>
     /// Модель в MQ, данные из АИХИТ
     /// </summary>
-    internal class AihitDataMq
+    public class AihitDataMq
     {
-        //TODO:данные из АИХИТ
+        public required string EK { get; set; }
+        public string? IP { get; set; }
+        public string? DBType { get; set; }
+        public string? APPType { get; set; }
+        public string? OSType { get; set; }
+        public string? WorkGroup { get; set; }
+        public required string Status { get; set; }
+        public required string ResponseArea { get; set; }
     }
 }

PARR.DAL/Models/Host.cs

@@ -20,7 +20,7 @@ namespace PARR.DAL.Models
 
         public int EkStatusCode { get; set; }
 
-        public required string IP { get; set; }
+        public string? IP { get; set; }
 
         //public string? RegionalEK { get; set; }
         //public string? LinkEK { get; set; }

PARR.EsppOrderManagerWorker/Program.cs

@@ -1,5 +1,4 @@
 using Elastic.CommonSchema.Serilog;
-using PARR.EsppApi;
 using PARR.EsppOrderManager;
 using PARR.EsppOrderManagerWorker;
 using Serilog;

docker-compose.dcproj

@@ -9,7 +9,8 @@
     <DockerServiceName>parr.api</DockerServiceName>
   </PropertyGroup>
   <ItemGroup>
-    <None Include="docker-compose.aihit-syncher.yml" />
+    <None Include="docker-compose.aihit-loader.yml" />
+    <None Include="docker-compose.aihit-syncer.yml" />
     <None Include="docker-compose.espp-order-loader.yml" />
     <None Include="docker-compose.espp-order-manager.yml" />
     <None Include="docker-compose.espp-schedule-sync.yml" />