369 lines
16 KiB
C#
369 lines
16 KiB
C#
using AutoMapper;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.Extensions.Logging;
|
||
using PARR.AIHIT.Services;
|
||
using PARR.DAL.Contracts;
|
||
using PARR.DAL.Extensions;
|
||
using PARR.DAL.Models;
|
||
using PARR.DAL.Models.AIHIT;
|
||
using PARR.DAL.Services.Interfaces;
|
||
using PARR.DAL.Services.Interfaces.AIHIT;
|
||
using System.Text;
|
||
|
||
namespace PARR.AIHIT
|
||
{
|
||
internal class Syncher : ISyncher
|
||
{
|
||
private readonly ILogger<Syncher> logger;
|
||
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,
|
||
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;
|
||
}
|
||
|
||
private async Task GetAppTypesAsync()
|
||
{
|
||
AppTypes = await appTypeService.Get().ToListAsync();
|
||
}
|
||
|
||
|
||
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)
|
||
{
|
||
logger.LogDebug($"-= Получение данных об ЭК зоны ответственности {respArea.Name} =-");
|
||
var eksFromAIHIT = aihitService.GetEKList(respArea.Value)?.ToList();
|
||
|
||
if (eksFromAIHIT == null)
|
||
continue;
|
||
|
||
//Удаляем текущие данные по зоне ответственности respArea
|
||
logger.LogDebug($"-= Удаление существующих данных об ЭК зоны ответственности {respArea.Name} =-");
|
||
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;
|
||
}
|
||
|
||
logger.LogDebug($"-= Создание новых записей об ЭК зоны ответственности {respArea.Name} =-");
|
||
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}");
|
||
}
|
||
|
||
logger.LogDebug($"-= Запись в базу данных записей об ЭК зоны ответственности {respArea.Name} ");
|
||
if (!await rawDataEKService.CommitAsync())
|
||
logger.LogError($"Информация о хостах зоны ответственности {respArea.Name} не записана ");
|
||
|
||
logger.LogDebug($"-= Конец синхронизации данных об ЭК зоны ответственности {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())) && e.EKFindCode.StartsWith("ВРТ-"))
|
||
.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 == 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 SyncApplicationAndHostAsync(Host? host, List<Application> hostApplications, bool isUpdateDateModified = false)
|
||
{
|
||
var isUpdated = false;
|
||
if (host == null)
|
||
return;
|
||
|
||
logger.LogDebug($"Host: {host.Ek}({host.IP}), начало синхронизации приложений ({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.Ek}({host.IP}), добавление нового приложения 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.Ek}({host.IP})");
|
||
|
||
isUpdated = true;
|
||
}
|
||
}
|
||
|
||
foreach (var app in host.ApplicationsInHosts)
|
||
{
|
||
var appToRemove = hostApplications.FirstOrDefault(a => a.Id == app.ApplicationId);
|
||
|
||
if (appToRemove == null)
|
||
{
|
||
//todo remove appToRemove
|
||
var obj = await appInHostService.Get().FirstOrDefaultAsync(t => t.ApplicationId == app.ApplicationId && t.HostId == host.Id);
|
||
if (obj != null)
|
||
{
|
||
logger.LogInformation($"Host: {host.Ek}({host.IP}), удаление неактуального приложения Application {app.Application?.Name}");
|
||
appInHostService.Delete(obj);
|
||
|
||
if (!await hostService.CommitAsync())
|
||
logger.LogError($"Не удалось удалить Application {app.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 async Task<List<Application>> GetAndFillApplicationsAsync(RawDataEK vm)
|
||
{
|
||
//logger.LogDebug($"Начало парсинга данных о программном обеспечении(СП, БД, ОС) из АИХ ИТ");
|
||
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.LogDebug($"Конец парсинга данных о программном обеспечении(СП, БД, ОС) из АИХ ИТ");
|
||
|
||
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();
|
||
|
||
return dbList;
|
||
}
|
||
|
||
|
||
private List<string> GetOSFromXML(string? osField)
|
||
{
|
||
if (string.IsNullOrEmpty(osField))
|
||
return new List<string>();
|
||
|
||
var osList = osField.Split(";").Distinct().ToList();
|
||
|
||
return osList;
|
||
}
|
||
|
||
|
||
private async Task<Application?> CreateAppIfNotExistAsync(string appName, ApplicationTypesEnum type)
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
} |