feat(aihitMainSyncer): реализована логика синхронизации таблиц unit.* с данными из АИХ ИТ

PARR.AIHITMainSyncer/Services/SyncerService.cs

@@ -13,18 +13,21 @@ namespace PARR.AIHITMainSyncer.Services
         private readonly ITransformService transformService;
         private readonly IUnitService unitService;
         private readonly IUnitFieldService unitFieldService;
+        private readonly IUnitFieldValueService unitFieldValueService;
 
         public SyncerService(
             ILogger<SyncerService> logger,
             ITransformService transformService,
             IUnitService unitService,
-            IUnitFieldService unitFieldService
+            IUnitFieldService unitFieldService,
+            IUnitFieldValueService unitFieldValueService
             )
         {
             this.logger = logger;
             this.transformService = transformService;
             this.unitService = unitService;
             this.unitFieldService = unitFieldService;
+            this.unitFieldValueService = unitFieldValueService;
         }
 
 
@@ -41,64 +44,88 @@ namespace PARR.AIHITMainSyncer.Services
 
         private async Task SyncUnitAsync(AihitMainDataMq objFromQuery)
         {
-            var fields = await GetFieldsInObjectAsync(objFromQuery);
+            var isChanged = false;
 
-            var unit = await unitService.GetUnitWithFieldsAsync(objFromQuery.Name);
+            var unit = await unitService.GetUnitByName(objFromQuery.Name);
 
-            if (unit == null)
-                unit = await CreateUnitAsync(objFromQuery);
+            foreach (var item in objFromQuery.Properties)
+            {   //актуализируем справочники в соответствии с пришедшими данными
+                var field = await CreateUnitFieldIfNotExistAsync(item.Key);
+                var value = await CreateFieldValueIfNotExistAsync(field, item.Value);
+
+                //Если ЭК не найден то создаём его
+                if (unit == null)
+                    unit = await CreateUnitAsync(objFromQuery);
+                //else
+                //    logger.LogDebug($"Найден Unit в БД: {unit.Name})");
+
+                //теперь проверяем наличие поля связанного с этим ЭК
+                if (SyncFields(unit, field) && !isChanged)
+                    isChanged = true;
+
+                //Синхронизируем значение
+                if (SyncValues(unit, field, value) && !isChanged)
+                    isChanged = true;
+            }
+
+            if (isChanged && !await unitService.CommitAsync())
+                logger.LogError($"Не удалось изменить Unit {objFromQuery.Name}");
             else
-                logger.LogDebug($"Найден Unit в БД: {unit.Name})");
-
-            await SyncFieldInUnitAsync(unit!, fields);
-
-
+                logger.LogInformation($"----- Набор данных в Unit изменён: {objFromQuery.Name}  -----");
         }
 
 
-        private async Task SyncFieldInUnitAsync(Unit unit, List<Guid> fieldsId)
+        private bool SyncFields(Unit unit, UnitField field)
         {
             var isChanged = false;
 
-            //Смотрим какие поля нам прислали, есть новые?
-            var newFields = fieldsId.Except(unit.UnitFields.Select(uf => uf.FieldId)).ToList();
+            var fieldInUnit = unit!.UnitFields.FirstOrDefault(u => u.FieldId == field.Id);
 
-            //добавляем если есть
-            if (newFields.Any())
+            if (fieldInUnit == null)
             {
-                if (!isChanged)
-                    isChanged = true;
-                newFields.ForEach(uf =>
-                {
-                    unit.UnitFields.Add(
-                        new UnitInField { UnitId = unit.Id, FieldId = uf, DateCreated = DateTimeOffset.UtcNow }
-                        );
-                });
+                if (!isChanged) isChanged = true;
+                unit.UnitFields.Add(
+                    new UnitInField { UnitId = unit.Id, FieldId = field.Id, DateCreated = DateTimeOffset.UtcNow }
+                    );
             }
 
-            //TODO: Удаление неактуальных
-
-            if (isChanged && !await unitFieldService.CommitAsync())
-                logger.LogError($"Не удалось изменить набор Fields в Unit {unit.Name}");
-            else
-                logger.LogInformation($"----- Набор Fields в Unit изменён: {unit.Name}  -----");
+            return isChanged;
         }
 
-        private async Task<List<Guid>> GetFieldsInObjectAsync(AihitMainDataMq objFromQuery)
+
+        private bool SyncValues(Unit unit, UnitField field, UnitFieldValue value)
         {
-            var fields = new List<Guid>();
+            var isChanged = false;
 
-            foreach (var item in objFromQuery.Properties)
+            var valueInUnit = unit!.UnitValues.FirstOrDefault(uv => uv.FieldId == field.Id);
+
+            if (valueInUnit == null)
             {
-                var field = await CreateUnitFieldIfNotExistAsync(item.Key);
-                fields.Add(field!.Id);
+                if (!isChanged) isChanged = true;
+                unit.UnitValues.Add(
+                    new UnitInValue
+                    {
+                        UnitId = unit.Id,
+                        FieldId = field.Id,
+                        ValueId = value.Id,
+                        DateCreated = DateTime.UtcNow
+                    }
+                );
+            }
+            else if (valueInUnit.Value != value)
+            {
+                if (!isChanged) isChanged = true;
+                {
+                    valueInUnit.ValueId = value.Id;
+                    valueInUnit.DateModified = DateTime.UtcNow;
+                }
             }
 
-            return fields;
+            return isChanged;
         }
 
 
-        private async Task<Unit?> CreateUnitAsync(AihitMainDataMq objFromQuery)
+        private async Task<Unit> CreateUnitAsync(AihitMainDataMq objFromQuery)
         {
             var unit = new Unit { Name = objFromQuery.Name.Trim() };
 
@@ -107,11 +134,11 @@ namespace PARR.AIHITMainSyncer.Services
             else
                 logger.LogInformation($"----- Создан Unit: {unit.Name}  -----");
 
-            return await unitService.GetUnitWithFieldsAsync(unit.Name);
+            return (await unitService.GetUnitByName(unit.Name))!;
         }
 
 
-        private async Task<UnitField?> CreateUnitFieldIfNotExistAsync(string name)
+        private async Task<UnitField> CreateUnitFieldIfNotExistAsync(string name)
         {
             var existUnitField = await unitFieldService.GetByAihitNameAsync(name);
 
@@ -122,7 +149,7 @@ namespace PARR.AIHITMainSyncer.Services
             {
                 Id = Guid.NewGuid(),
                 AihitName = name.Trim(),
-                EsppName = null
+                EsppName = null,
             };
 
             if (!await unitFieldService.CreateAsync(field) || !await unitFieldService.CommitAsync())
@@ -130,7 +157,61 @@ namespace PARR.AIHITMainSyncer.Services
             else
                 logger.LogInformation($"Создана запись а таблице Fields: {name}, {field.ToJson()}");
 
-            return await unitFieldService.GetAsync(field.Id);
+            return (await unitFieldService.GetAsync(field.Id))!;
+        }
+
+
+        private async Task<UnitFieldValue> CreateFieldValueIfNotExistAsync(UnitField field, string? value)
+        {
+            var existUnitFieldValue = await unitFieldValueService.GetByValueNameAsync(value);
+
+            //если значение существует отдаем его
+            if (existUnitFieldValue != null)
+            {
+                //проверяем связь с таблицей Fields
+                if (existUnitFieldValue.FieldValues.FirstOrDefault(fv => fv.FieldId == field.Id) == null)
+                {
+                    var unitFieldInUnitFieldValue = new UnitFieldInUnitFieldValue
+                    {
+                        FieldId = field.Id,
+                        FieldValueId = existUnitFieldValue.Id,
+                        DateCreated = DateTime.UtcNow,
+                    };
+
+                    existUnitFieldValue.FieldValues.Add(unitFieldInUnitFieldValue);
+
+                    if (!await unitFieldValueService.CommitAsync())
+                        logger.LogError($"Не удалось создать связь таблицы FieldValues и Fields: {unitFieldValueService.ToJson()}");
+                    else
+                        logger.LogInformation($"Создана связь таблицы FieldValues и Fields: {unitFieldValueService.ToJson()}");
+                }
+
+                return existUnitFieldValue;
+            }
+
+            //значение не найдено значит создаём его
+            var newValue = new UnitFieldValue
+            {
+                Id = Guid.NewGuid(),
+                Value = (value == null) ? null : value.Trim()
+            };
+            //и привязываем значение к полю
+            newValue.FieldValues.Add(
+                new UnitFieldInUnitFieldValue
+                {
+                    FieldId = field.Id,
+                    FieldValueId = newValue.Id,
+                    DateCreated = DateTime.UtcNow,
+                }
+            );
+
+            //пишем в базу данных
+            if (!await unitFieldValueService.CreateAsync(newValue) || !await unitFieldValueService.CommitAsync())
+                logger.LogError($"Не удалось создать запись в таблице Values: {newValue.Value}, {newValue.ToJson()}");
+            else
+                logger.LogInformation($"Создана запись а таблице Values: {newValue.Value}, {newValue.ToJson()}");
+
+            return (await unitFieldValueService.GetAsync(newValue.Id))!;
         }
     }
 }