960 lines
49 KiB
C#
960 lines
49 KiB
C#
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.Extensions.Logging;
|
||
using PARR.BLL.Domain.Mq;
|
||
using PARR.BLL.Services.Interfaces;
|
||
using PARR.Common.Domain;
|
||
using PARR.Constants;
|
||
using PARR.DAL.Contracts;
|
||
using PARR.DAL.DomainServices.Interfaces;
|
||
using PARR.DAL.Models;
|
||
using PARR.DAL.Models.Job;
|
||
using PARR.DAL.Models.Unit;
|
||
using PARR.DAL.Services.Interfaces;
|
||
using PARR.DAL.Services.Interfaces.Job;
|
||
using PARR.DAL.Services.Interfaces.Unit;
|
||
using PARR.DAL.TransformServices;
|
||
using PARR.TemplateMatcher.Settings;
|
||
using System.Text.Json;
|
||
|
||
namespace PARR.TemplateMatcher
|
||
{
|
||
internal class TemplateMatcher : ITemplateMatcher
|
||
{
|
||
private const int UnusedCandidateBatchSize = 10;
|
||
private const bool DefaultUnusedTemplateState = false;
|
||
private const bool DefaultUnusedScheduleState = false;
|
||
private const bool DefaultUsedTemplateState = false;
|
||
private const bool DefaultUsedScheduleState = false;
|
||
|
||
private readonly ILogger<TemplateMatcher> logger;
|
||
private readonly IUnitFilterService unitFilterService;
|
||
private readonly IUnitInUnitService unitInUnitService;
|
||
private readonly IUnitInValueService unitInValueService; // Добавлено
|
||
private readonly IUnitService unitService; // Добавлено
|
||
private readonly MqSettings mqSettings;
|
||
private readonly IMqService mqService;
|
||
private readonly ITemplateService templateService;
|
||
private readonly IJobService jobService;
|
||
private readonly IJobGroupService jobGroupService;
|
||
private readonly IShortcodesService shortcodesService;
|
||
private readonly IEsppScheduleTransformService esppScheduleTransformService;
|
||
|
||
public TemplateMatcher(
|
||
ILogger<TemplateMatcher> logger,
|
||
IUnitFilterService unitFilterService,
|
||
IUnitInUnitService unitInUnitService,
|
||
IUnitInValueService unitInValueService,
|
||
IUnitService unitService,
|
||
MqSettings mqSettings,
|
||
IMqService mqService,
|
||
ITemplateService templateService,
|
||
IJobService jobService,
|
||
IJobGroupService jobGroupService,
|
||
IShortcodesService shortcodesService,
|
||
IEsppScheduleTransformService esppScheduleTransformService)
|
||
{
|
||
this.logger = logger;
|
||
this.unitFilterService = unitFilterService;
|
||
this.unitInUnitService = unitInUnitService;
|
||
this.unitInValueService = unitInValueService;
|
||
this.unitService = unitService;
|
||
this.mqSettings = mqSettings;
|
||
this.mqService = mqService;
|
||
this.templateService = templateService;
|
||
this.jobService = jobService;
|
||
this.jobGroupService = jobGroupService;
|
||
this.shortcodesService = shortcodesService;
|
||
this.esppScheduleTransformService = esppScheduleTransformService;
|
||
}
|
||
|
||
public async Task SyncTemplatesForJob(Guid jobId, HistoryInitiator initiator)
|
||
{
|
||
logger.LogDebug("Начало синхронизации шаблонов для JobId {JobId}", jobId);
|
||
|
||
var expectedUnitIds = await GetExpectedUnitIdsAsync(jobId) ?? new HashSet<Guid>();
|
||
logger.LogDebug("JobId {JobId}: найдено {Count} UnitId по фильтрам.", jobId, expectedUnitIds.Count);
|
||
|
||
var job = await GetJobWithGroupAndAutoControlAsync(jobId);
|
||
if (job == null)
|
||
{
|
||
logger.LogError("Job с Id {JobId} не найден.", jobId);
|
||
return;
|
||
}
|
||
|
||
// Проверяем, является ли Job "групповым"
|
||
bool isGroupJob = job.Group != null && job.Group.GroupType?.Code == JobGroupTypesEnum.Group;
|
||
|
||
if (isGroupJob && job.Group.GroupingUnitFieldId.HasValue)
|
||
{
|
||
logger.LogInformation("Job {JobId} является групповым. Используйте SyncTemplatesForJobGroup для синхронизации.", jobId);
|
||
return; // Ничего не делаем для группового Job
|
||
}
|
||
else
|
||
{
|
||
await SyncSimpleTemplatesAsync(job, expectedUnitIds, initiator);
|
||
}
|
||
|
||
logger.LogInformation("Синхронизация завершена для JobId {JobId}.", jobId);
|
||
}
|
||
|
||
public async Task SyncTemplatesForJobGroup(Guid jobGroupId, HistoryInitiator initiator)
|
||
{
|
||
logger.LogDebug("Начало синхронизации шаблонов для JobGroup {JobGroupId}", jobGroupId);
|
||
|
||
// 1. Получить JobGroup и связанные Job'ы
|
||
var jobGroup = await jobGroupService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Include(jg => jg.Jobs)
|
||
.ThenInclude(j => j.AutoControl)
|
||
.Include(jg => jg.Jobs)
|
||
.ThenInclude(j => j.UnitFilters)
|
||
.ThenInclude(uf => uf.RelationshipFilters)
|
||
.FirstOrDefaultAsync(jg => jg.Id == jobGroupId);
|
||
|
||
if (jobGroup == null || jobGroup.Jobs == null || !jobGroup.Jobs.Any())
|
||
{
|
||
logger.LogWarning("JobGroup {JobGroupId} не найден или не содержит Job'ов.", jobGroupId);
|
||
return;
|
||
}
|
||
|
||
var jobsInGroup = jobGroup.Jobs.ToList();
|
||
|
||
// 2. Найти Job с максимальным MaxValueRelationships
|
||
var maxJob = jobsInGroup
|
||
.Where(j => j.MaxValueRelationships.HasValue)
|
||
.OrderByDescending(j => j.MaxValueRelationships)
|
||
.FirstOrDefault();
|
||
|
||
if (maxJob == null)
|
||
{
|
||
logger.LogWarning("В JobGroup {JobGroupId} не найдено Job с установленным MaxValueRelationships.", jobGroupId);
|
||
// Возможно, нужно обработать случай, когда MaxValueRelationships не установлено ни у одного Job.
|
||
// Пока просто выйдем.
|
||
return;
|
||
}
|
||
|
||
// Проверяем, что UnitFilters и RelationshipFilters загружены
|
||
if (maxJob.UnitFilters == null)
|
||
{
|
||
logger.LogWarning("Job {JobId} не содержит UnitFilters.", maxJob.Id);
|
||
// Продолжить с пустыми фильтрами или выйти?
|
||
// Пока продолжим с пустым списком.
|
||
}
|
||
|
||
logger.LogDebug("Используется Job {JobId} с максимальным MaxValueRelationships ({MaxValue}) для фильтрации.", maxJob.Id, maxJob.MaxValueRelationships);
|
||
|
||
// 3. Использовать фильтры maxJob для получения expectedUnitIds
|
||
var expectedUnitIds = await unitFilterService.GetUnitsIdByJobFilterAsync(maxJob.Id);
|
||
if (expectedUnitIds == null || !expectedUnitIds.Any())
|
||
{
|
||
logger.LogInformation("Для JobGroup {JobGroupId} фильтры не дали Unit'ов.", jobGroupId);
|
||
// Деактивировать все шаблоны для всех Job в группе?
|
||
// Пока просто выйдем.
|
||
return;
|
||
}
|
||
|
||
// 4. Отфильтровать expectedUnitIds по GroupingUnitFieldId
|
||
if (!jobGroup.GroupingUnitFieldId.HasValue)
|
||
{
|
||
logger.LogError("JobGroup {JobGroupId} не имеет GroupingUnitFieldId, необходимого для группировки.", jobGroupId);
|
||
return;
|
||
}
|
||
|
||
var groupingFieldId = jobGroup.GroupingUnitFieldId.Value;
|
||
|
||
// --- ИСПРАВЛЕНИЕ: Разбиваем запрос на части ---
|
||
// Загрузить UnitValues для отфильтрованных юнитов, чтобы проверить GroupingUnitFieldId
|
||
var filteredUnits = await unitService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.AsSplitQuery() // Добавлено
|
||
.Include(t => t.UnitValues) // Добавлено
|
||
.ThenInclude(t => t.Value) // Добавлено
|
||
.Where(u => expectedUnitIds.Contains(u.Id))
|
||
.ToListAsync(); // Сначала загружаем Unit'ы
|
||
|
||
// Затем фильтруем их UnitValues и собираем UnitId
|
||
var unitIdsWithValidGroupingFieldSet = filteredUnits
|
||
.Where(u => u.UnitValues.Any(uv => uv.FieldId == groupingFieldId && uv.Value != null && !string.IsNullOrEmpty(uv.Value.Value)))
|
||
.Select(u => u.Id)
|
||
.ToHashSet(); // Создаем HashSet
|
||
|
||
logger.LogDebug("После фильтрации по GroupingUnitFieldId осталось {Count} юнитов.", unitIdsWithValidGroupingFieldSet.Count);
|
||
|
||
if (!unitIdsWithValidGroupingFieldSet.Any())
|
||
{
|
||
logger.LogInformation("После фильтрации по GroupingUnitFieldId в JobGroup {JobGroupId} не осталось юнитов.", jobGroupId);
|
||
return;
|
||
}
|
||
|
||
// --- НОВАЯ ЛОГИКА: Применение RelationshipFilters ---
|
||
// Найти связи UnitInUnit для unitIdsWithValidGroupingFieldSet
|
||
var potentialUnitInUnitLinks = await unitInUnitService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Where(link => unitIdsWithValidGroupingFieldSet.Contains(link.ChildUnitId))
|
||
.ToListAsync();
|
||
|
||
logger.LogDebug("Найдено {Count} потенциальных связей UnitInUnit до применения RelationshipFilters.", potentialUnitInUnitLinks.Count);
|
||
|
||
// Получить RelationshipFilters из maxJob
|
||
var relationshipFilters = maxJob.UnitFilters?.SelectMany(uf => uf.RelationshipFilters).ToList() ?? new List<JobRelationshipFilter>();
|
||
|
||
if (relationshipFilters.Any())
|
||
{
|
||
// Загрузить UnitInValue для ParentUnitId и ChildUnitId из potentialUnitInUnitLinks
|
||
var allParentIds = potentialUnitInUnitLinks.Select(l => l.ParentUnitId).ToHashSet();
|
||
var allChildIds = potentialUnitInUnitLinks.Select(l => l.ChildUnitId).ToHashSet();
|
||
|
||
var parentUnitValues = await unitInValueService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Include(uv => uv.Field) // Добавлено
|
||
.Include(uv => uv.Value) // Добавлено
|
||
.Where(uv => allParentIds.Contains(uv.UnitId))
|
||
.ToListAsync();
|
||
|
||
var childUnitValues = await unitInValueService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Include(uv => uv.Field) // Добавлено
|
||
.Include(uv => uv.Value) // Добавлено
|
||
.Where(uv => allChildIds.Contains(uv.UnitId))
|
||
.ToListAsync();
|
||
|
||
// Сгруппировать значения по UnitId для быстрого доступа
|
||
var parentValuesMap = parentUnitValues
|
||
.GroupBy(uv => uv.UnitId)
|
||
.ToDictionary(g => g.Key, g => g.ToList());
|
||
|
||
var childValuesMap = childUnitValues
|
||
.GroupBy(uv => uv.UnitId)
|
||
.ToDictionary(g => g.Key, g => g.ToList());
|
||
|
||
// Применить фильтры к связям
|
||
var filteredUnitInUnitLinks = new List<UnitInUnit>();
|
||
foreach (var link in potentialUnitInUnitLinks)
|
||
{
|
||
bool linkMatchesAllFilters = true;
|
||
|
||
foreach (var rf in relationshipFilters)
|
||
{
|
||
var valuesToCheck = rf.IsParent ? parentValuesMap.GetValueOrDefault(link.ParentUnitId, new List<UnitInValue>()) : childValuesMap.GetValueOrDefault(link.ChildUnitId, new List<UnitInValue>());
|
||
|
||
bool filterMatch = valuesToCheck.Any(uv =>
|
||
uv.FieldId == rf.FieldId &&
|
||
uv.Value != null &&
|
||
uv.Value.Value != null &&
|
||
uv.Value.Value.Contains(rf.ValueMask ?? "", StringComparison.OrdinalIgnoreCase)
|
||
);
|
||
|
||
if (rf.IsInverse)
|
||
filterMatch = !filterMatch;
|
||
|
||
if (!filterMatch)
|
||
{
|
||
linkMatchesAllFilters = false;
|
||
break; // Не подходит под один из фильтров
|
||
}
|
||
}
|
||
|
||
if (linkMatchesAllFilters)
|
||
{
|
||
filteredUnitInUnitLinks.Add(link);
|
||
}
|
||
}
|
||
|
||
potentialUnitInUnitLinks = filteredUnitInUnitLinks; // Заменяем на отфильтрованные
|
||
}
|
||
|
||
logger.LogDebug("Осталось {Count} связей UnitInUnit после применения RelationshipFilters.", potentialUnitInUnitLinks.Count);
|
||
|
||
// 6. Сгруппировать ChildUnitId по ParentUnitId (региональный ЭК) из ОТФИЛЬТРОВАННЫХ связей
|
||
var groupedByRegional = potentialUnitInUnitLinks
|
||
.GroupBy(link => link.ParentUnitId)
|
||
.ToDictionary(g => g.Key, g => g.Select(l => l.ChildUnitId).ToList());
|
||
|
||
logger.LogDebug("Сформировано {Count} групп по региональным юнитам.", groupedByRegional.Count);
|
||
|
||
// 7. Разбить каждую группу и сопоставить с Job
|
||
// Для каждого регионального юнита и его дочерних юнитов:
|
||
foreach (var kvp in groupedByRegional)
|
||
{
|
||
var regionalUnitId = kvp.Key;
|
||
var childUnitIds = kvp.Value;
|
||
|
||
logger.LogDebug("Обработка регионального юнита {RegionalUnitId} с {Count} дочерними юнитами.", regionalUnitId, childUnitIds.Count);
|
||
|
||
// Применяем ограничение MaxValueRelationships maxJob
|
||
int maxValueForSplitting = maxJob.MaxValueRelationships.Value; // Уже проверили, что не null
|
||
var childUnitGroups = childUnitIds
|
||
.Select((id, index) => new { id, groupIndex = index / maxValueForSplitting })
|
||
.GroupBy(x => x.groupIndex)
|
||
.Select(g => g.Select(x => x.id).ToList())
|
||
.ToList();
|
||
|
||
logger.LogDebug("Региональный юнит {RegionalUnitId}: разбит на {GroupCount} подгрупп.", regionalUnitId, childUnitGroups.Count);
|
||
|
||
// Для каждой подгруппы:
|
||
for (int i = 0; i < childUnitGroups.Count; i++)
|
||
{
|
||
var subGroup = childUnitGroups[i];
|
||
var subGroupSize = subGroup.Count;
|
||
|
||
logger.LogDebug("Обработка подгруппы {Index} регионального юнита {RegionalUnitId}, размер {Size}.", i, regionalUnitId, subGroupSize);
|
||
|
||
// 8. Найти подходящий Job для подгруппы
|
||
// Попробовать найти Job с MaxValueRelationships, равным размеру подгруппы
|
||
var targetJob = jobsInGroup
|
||
.Where(j => j.MaxValueRelationships.HasValue && j.MaxValueRelationships.Value == subGroupSize)
|
||
.FirstOrDefault();
|
||
|
||
if (targetJob == null)
|
||
{
|
||
// Найти Job с MaxValueRelationships >= размеру подгруппы, но минимально подходящее
|
||
targetJob = jobsInGroup
|
||
.Where(j => j.MaxValueRelationships.HasValue && j.MaxValueRelationships.Value >= subGroupSize)
|
||
.OrderBy(j => j.MaxValueRelationships.Value)
|
||
.FirstOrDefault();
|
||
}
|
||
|
||
if (targetJob == null)
|
||
{
|
||
// Если подходящий Job не найден, используем maxJob
|
||
targetJob = maxJob;
|
||
logger.LogDebug("Для подгруппы {Index} регионального юнита {RegionalUnitId} не найден подходящий Job, используем maxJob {MaxJobId}.", i, regionalUnitId, maxJob.Id);
|
||
}
|
||
else
|
||
{
|
||
logger.LogDebug("Для подгруппы {Index} регионального юнита {RegionalUnitId} выбран Job {TargetJobId} с MaxValueRelationships {MaxValue}.", i, regionalUnitId, targetJob.Id, targetJob.MaxValueRelationships);
|
||
}
|
||
|
||
// 9. Загрузить существующие шаблоны для targetJob, связанные с regionalUnitId
|
||
var existingTemplatesForRegional = await templateService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Include(t => t.UnitsInTemplate)
|
||
.Where(t => t.JobId == targetJob.Id && t.UnitId == regionalUnitId && t.Index == i)
|
||
.ToListAsync();
|
||
|
||
Template existingTemplateForSubGroup = existingTemplatesForRegional.FirstOrDefault();
|
||
|
||
if (existingTemplateForSubGroup != null)
|
||
{
|
||
// Проверить, изменились ли юниты
|
||
var existingUnitIds = existingTemplateForSubGroup.UnitsInTemplate.Select(uit => uit.UnitId).ToHashSet();
|
||
var newUnitIds = subGroup.ToHashSet();
|
||
|
||
if (existingUnitIds.SetEquals(newUnitIds))
|
||
{
|
||
logger.LogDebug("Шаблон {TemplateId} (Job {JobId}, Regional {RegionalId}, Index {Index}) актуален.", existingTemplateForSubGroup.Id, targetJob.Id, regionalUnitId, i);
|
||
// Возможно, нужно обновить имя или статус, если изменились фильтры или AutoControl
|
||
// Пока оставим как есть, если структура не изменилась.
|
||
}
|
||
else
|
||
{
|
||
logger.LogDebug("Шаблон {TemplateId} (Job {JobId}, Regional {RegionalId}, Index {Index}) требует обновления юнитов.", existingTemplateForSubGroup.Id, targetJob.Id, regionalUnitId, i);
|
||
// Обновляем существующий шаблон
|
||
await UpdateTemplateUnitsAsync(existingTemplateForSubGroup, subGroup, targetJob, initiator);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// --- ИСПОЛЬЗУЕМ СТАНДАРТНЫЙ МЕТОД TryReuseOneUnusedTemplateAsync ---
|
||
var reusableTemplate = await TryReuseOneUnusedTemplateAsync(targetJob.Id, regionalUnitId, initiator); // передаём regionalUnitId как unitId для старого метода
|
||
|
||
if (reusableTemplate != null) // если захват успешен
|
||
{
|
||
logger.LogInformation("Переиспользован шаблон {TemplateId} для Job {JobId}, регионального юнита {RegionalId}, Index {Index}.", reusableTemplate.Id, targetJob.Id, regionalUnitId, i);
|
||
|
||
// Подготовить сообщение для TemplateUpdater с новыми параметрами
|
||
var expectedName = await GetNormalizedTemplateNameAsync(targetJob, regionalUnitId, i);
|
||
var nextRun = await GetNextRunAsync(targetJob); // всегда пересчитываем для нового назначения
|
||
|
||
var updateRequest = new TemplateUpdaterMq
|
||
{
|
||
TemplateId = reusableTemplate.Id, // ID захваченного шаблона
|
||
JobId = targetJob.Id, // Новый JobId
|
||
UnitId = regionalUnitId, // Новый UnitId (региональный)
|
||
Name = expectedName,
|
||
IsActiveTemplate = targetJob.AutoControl?.InitUsedTemplateState ?? DefaultUsedTemplateState,
|
||
IsActiveSchedule = targetJob.AutoControl?.InitUsedScheduleState ?? DefaultUsedScheduleState,
|
||
StatusTypeId = TemplateStatusTypeEnum.Used,
|
||
Initiator = initiator,
|
||
NextRun = nextRun,
|
||
Index = i, // Новый Index
|
||
UnitsInTemplate = subGroup // Новые UnitsInTemplate
|
||
};
|
||
|
||
await SendTemplateUpdateMessage(updateRequest);
|
||
}
|
||
else
|
||
{
|
||
// Создать новый шаблон
|
||
logger.LogDebug("Создание нового шаблона для Job {JobId}, Regional {RegionalId}, Index {Index}, с {Count} юнитами.", targetJob.Id, regionalUnitId, i, subGroup.Count);
|
||
await CreateGroupedTemplateAsync(targetJob.Id, regionalUnitId, subGroup, i, initiator);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 10. Деактивировать шаблоны, которые больше не соответствуют ни одной подгруппе
|
||
// Это требует сбора всех ожидаемых (JobId, UnitId, Index) и сравнения с существующими.
|
||
// Соберем ожидаемые комбинации
|
||
var expectedTemplateKeys = new HashSet<(Guid JobId, Guid UnitId, int Index)>();
|
||
foreach (var kvp in groupedByRegional)
|
||
{
|
||
var regionalUnitId = kvp.Key;
|
||
var childUnitIds = kvp.Value;
|
||
int maxValueForSplitting = maxJob.MaxValueRelationships.Value;
|
||
var childUnitGroups = childUnitIds
|
||
.Select((id, index) => new { id, groupIndex = index / maxValueForSplitting })
|
||
.GroupBy(x => x.groupIndex)
|
||
.Select(g => g.Select(x => x.id).ToList())
|
||
.ToList();
|
||
|
||
for (int i = 0; i < childUnitGroups.Count; i++)
|
||
{
|
||
var subGroup = childUnitGroups[i];
|
||
var subGroupSize = subGroup.Count;
|
||
|
||
var targetJob = jobsInGroup
|
||
.Where(j => j.MaxValueRelationships.HasValue && j.MaxValueRelationships.Value == subGroupSize)
|
||
.FirstOrDefault();
|
||
|
||
if (targetJob == null)
|
||
{
|
||
targetJob = jobsInGroup
|
||
.Where(j => j.MaxValueRelationships.HasValue && j.MaxValueRelationships.Value >= subGroupSize)
|
||
.OrderBy(j => j.MaxValueRelationships.Value)
|
||
.FirstOrDefault();
|
||
}
|
||
|
||
if (targetJob == null) targetJob = maxJob;
|
||
|
||
// Исправлено: используем конкретные типы для кортежа
|
||
expectedTemplateKeys.Add((targetJob.Id, regionalUnitId, i));
|
||
}
|
||
}
|
||
|
||
// Загрузить *все* шаблоны для всех Job в группе, связанные с региональными юнитами из групп
|
||
var allRegionalUnitIds = groupedByRegional.Keys.ToHashSet();
|
||
var allJobIdsInGroup = jobsInGroup.Select(j => j.Id).ToHashSet();
|
||
|
||
var allExistingTemplatesInGroup = await templateService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Include(t => t.UnitsInTemplate)
|
||
.Where(t => allJobIdsInGroup.Contains(t.JobId) && allRegionalUnitIds.Contains(t.UnitId))
|
||
.ToListAsync();
|
||
|
||
foreach (var existingTemplate in allExistingTemplatesInGroup)
|
||
{
|
||
// Исправлено: используем конкретные типы для ключа
|
||
var key = (existingTemplate.JobId, existingTemplate.UnitId, existingTemplate.Index ?? -1);
|
||
if (!expectedTemplateKeys.Contains(key))
|
||
{
|
||
logger.LogInformation("Деактивация лишнего шаблона {TemplateId} (Job {JobId}, Regional {UnitId}, Index {Index}).", existingTemplate.Id, existingTemplate.JobId, existingTemplate.UnitId, existingTemplate.Index);
|
||
await DeactivateTemplateAsync(existingTemplate, existingTemplate.JobId, initiator);
|
||
}
|
||
}
|
||
|
||
logger.LogInformation("Синхронизация шаблонов завершена для JobGroup {JobGroupId}.", jobGroupId);
|
||
}
|
||
|
||
|
||
private async Task SyncSimpleTemplatesAsync(Job job, HashSet<Guid> expectedUnitIds, HistoryInitiator initiator)
|
||
{
|
||
logger.LogDebug("Синхронизация обычных шаблонов для JobId {JobId}", job.Id);
|
||
|
||
var existingTemplates = await templateService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Where(t => t.JobId == job.Id)
|
||
.ToListAsync();
|
||
|
||
logger.LogDebug("JobId {JobId}: {Expected} ожидаемых UnitId, {Existing} существующих шаблонов.",
|
||
job.Id, expectedUnitIds.Count, existingTemplates.Count);
|
||
|
||
// Обработка случая: фильтр вернул 0 UnitId → деактивировать ВСЕ шаблоны
|
||
if (!expectedUnitIds.Any())
|
||
{
|
||
if (existingTemplates.Any())
|
||
{
|
||
logger.LogInformation("Для JobId {JobId} фильтры не дали Unit'ов — будет деактивировано {Count} шаблонов.",
|
||
job.Id, existingTemplates.Count);
|
||
|
||
foreach (var template in existingTemplates)
|
||
{
|
||
await DeactivateTemplateAsync(template, job.Id, initiator);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
logger.LogInformation("Для JobId {JobId} нет Unit'ов по фильтрам и нет существующих шаблонов — синхронизация завершена.", job.Id);
|
||
}
|
||
|
||
logger.LogInformation("Синхронизация завершена для JobId {JobId} (фильтр пуст).", job.Id);
|
||
return;
|
||
}
|
||
|
||
// Деактивация шаблонов, которые вышли из фильтра
|
||
var templatesToDeactivate = existingTemplates
|
||
.Where(t => !expectedUnitIds.Contains(t.UnitId))
|
||
.ToList();
|
||
|
||
foreach (var template in templatesToDeactivate)
|
||
{
|
||
await DeactivateTemplateAsync(template, job.Id, initiator);
|
||
}
|
||
|
||
// Перечитываем шаблоны после деактивации
|
||
existingTemplates = await templateService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Where(t => t.JobId == job.Id)
|
||
.ToListAsync();
|
||
|
||
var unitToTemplate = existingTemplates.ToDictionary(t => t.UnitId, t => t);
|
||
|
||
// UnitId без шаблона → попытка переиспользования или создание
|
||
var unitIdsMissingTemplates = expectedUnitIds
|
||
.Where(unitId => !unitToTemplate.ContainsKey(unitId))
|
||
.ToList();
|
||
|
||
var unitIdsToCreateFresh = new List<Guid>();
|
||
|
||
foreach (var unitId in unitIdsMissingTemplates)
|
||
{
|
||
var reused = await TryReuseOneUnusedTemplateAsync(job.Id, unitId, initiator);
|
||
if (reused != null)
|
||
{
|
||
logger.LogInformation("Переиспользован шаблон {TemplateId} для UnitId {UnitId}.", reused.Id, unitId);
|
||
|
||
var expectedName = await GetNormalizedTemplateNameAsync(job, unitId);
|
||
var nextRun = await GetNextRunAsync(job); // всегда пересчитываем для нового назначения
|
||
|
||
var updateRequest = new TemplateUpdaterMq
|
||
{
|
||
TemplateId = reused.Id,
|
||
JobId = job.Id,
|
||
UnitId = unitId,
|
||
Name = expectedName,
|
||
IsActiveTemplate = job.AutoControl?.InitUsedTemplateState ?? DefaultUsedTemplateState,
|
||
IsActiveSchedule = job.AutoControl?.InitUsedScheduleState ?? DefaultUsedScheduleState,
|
||
StatusTypeId = TemplateStatusTypeEnum.Used,
|
||
Initiator = initiator,
|
||
NextRun = nextRun,
|
||
UnitsInTemplate = new List<Guid>()
|
||
};
|
||
|
||
await SendTemplateUpdateMessage(updateRequest);
|
||
}
|
||
else
|
||
{
|
||
logger.LogInformation("Нет доступных Unused-шаблонов для UnitId {UnitId} → создадим новый.", unitId);
|
||
unitIdsToCreateFresh.Add(unitId);
|
||
}
|
||
}
|
||
|
||
// Обновление/реактивация шаблонов, оставшихся в фильтре
|
||
var templatesInFilter = existingTemplates
|
||
.Where(t => expectedUnitIds.Contains(t.UnitId))
|
||
.ToList();
|
||
|
||
foreach (var template in templatesInFilter)
|
||
{
|
||
var expectedName = await GetNormalizedTemplateNameAsync(job, template.UnitId);
|
||
await ReactivateOrRenameTemplateAsync(template, job, expectedName, initiator);
|
||
}
|
||
|
||
// Создание новых шаблонов
|
||
foreach (var unitId in unitIdsToCreateFresh)
|
||
{
|
||
await SendTemplateGeneratorMessageAsync(job.Id, unitId, initiator);
|
||
}
|
||
}
|
||
|
||
|
||
public async Task UpdateTemplatesForJob(Guid jobId, HistoryInitiator initiator)
|
||
{
|
||
logger.LogDebug("Начало обновления шаблонов для JobId {JobId}", jobId);
|
||
|
||
var existingTemplates = await templateService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Where(t => t.JobId == jobId)
|
||
.ToListAsync();
|
||
|
||
if (!existingTemplates.Any()) return;
|
||
|
||
var job = await GetJobWithGroupAndAutoControlAsync(jobId);
|
||
if (job == null) return;
|
||
|
||
var currentUnitIds = await GetExpectedUnitIdsAsync(jobId) ?? new HashSet<Guid>();
|
||
logger.LogDebug("JobId {JobId}: {Count} UnitId по текущему фильтру.", jobId, currentUnitIds.Count);
|
||
|
||
foreach (var template in existingTemplates)
|
||
{
|
||
logger.LogDebug("Обработка шаблона {TemplateId} (UnitId {UnitId}).", template.Id, template.UnitId);
|
||
|
||
bool unitStillInFilter = currentUnitIds.Contains(template.UnitId);
|
||
var expectedName = await GetNormalizedTemplateNameAsync(job, template.UnitId);
|
||
|
||
TemplateStatusTypeEnum targetStatus;
|
||
bool targetIsActiveTemplate;
|
||
bool targetIsActiveSchedule;
|
||
|
||
if (unitStillInFilter)
|
||
{
|
||
targetStatus = TemplateStatusTypeEnum.Used;
|
||
targetIsActiveTemplate = template.IsActiveTemplate;
|
||
targetIsActiveSchedule = template.IsActiveSchedule;
|
||
}
|
||
else
|
||
{
|
||
targetStatus = TemplateStatusTypeEnum.Unused;
|
||
targetIsActiveTemplate = DefaultUnusedTemplateState;
|
||
targetIsActiveSchedule = DefaultUnusedScheduleState;
|
||
expectedName = GetTemplateNameForUnused(expectedName);
|
||
logger.LogInformation("Шаблон {TemplateId} (UnitId {UnitId}) → деактивация.", template.Id, template.UnitId);
|
||
}
|
||
|
||
bool needsUpdate = template.StatusTypeId != TemplateStatusTypeEnum.Updating &&
|
||
(
|
||
// 1. Статус изменился (например, Used → Unused или Unused → Used)
|
||
template.StatusTypeId != targetStatus ||
|
||
|
||
// 2. Для Used — имя должно соответствовать шаблону
|
||
(targetStatus == TemplateStatusTypeEnum.Used && template.Name != expectedName) ||
|
||
|
||
// 3. Флаги изменились (редко, но возможно через AutoControl изменение)
|
||
template.IsActiveTemplate != targetIsActiveTemplate ||
|
||
template.IsActiveSchedule != targetIsActiveSchedule
|
||
);
|
||
|
||
if (!needsUpdate) continue;
|
||
|
||
template.StatusTypeId = TemplateStatusTypeEnum.Updating;
|
||
template.DateModified = DateTimeOffset.UtcNow;
|
||
|
||
if (!await templateService.CommitAsync(initiator))
|
||
{
|
||
logger.LogError("Не удалось перевести шаблон {TemplateId} в Updating.", template.Id);
|
||
continue;
|
||
}
|
||
|
||
var nextRun = await GetNextRunAsync(job, template.NextRun);
|
||
|
||
var updateRequest = new TemplateUpdaterMq
|
||
{
|
||
TemplateId = template.Id,
|
||
JobId = jobId,
|
||
UnitId = template.UnitId,
|
||
Name = expectedName,
|
||
IsActiveTemplate = targetIsActiveTemplate,
|
||
IsActiveSchedule = targetIsActiveSchedule,
|
||
LastRun = template.LastRun,
|
||
NextRun = nextRun,
|
||
Index = template.Index,
|
||
StatusTypeId = targetStatus,
|
||
Initiator = initiator,
|
||
UnitsInTemplate = template.UnitsInTemplate.Select(t => t.UnitId).ToList()
|
||
};
|
||
|
||
await SendTemplateUpdateMessage(updateRequest);
|
||
}
|
||
|
||
logger.LogInformation("Обновление шаблонов завершено для JobId {JobId}.", jobId);
|
||
}
|
||
|
||
|
||
private async Task UpdateTemplateUnitsAsync(Template template, List<Guid> newUnitIds, Job job, HistoryInitiator initiator)
|
||
{
|
||
// Обновляем шаблон как "Updating"
|
||
template.StatusTypeId = TemplateStatusTypeEnum.Updating;
|
||
template.DateModified = DateTimeOffset.UtcNow;
|
||
|
||
if (!await templateService.CommitAsync(initiator))
|
||
{
|
||
logger.LogError("Не удалось перевести шаблон {TemplateId} в Updating для обновления юнитов.", template.Id);
|
||
return;
|
||
}
|
||
|
||
// Здесь нужно обновить UnitsInTemplate.
|
||
// Это может быть сделано через TemplateUpdaterMq, если он поддерживает передачу нового списка юнитов.
|
||
// Или напрямую в сервисе шаблонов, если логика обновления простая.
|
||
// Пока отправим сообщение в TemplateUpdater.
|
||
|
||
var expectedName = await GetNormalizedTemplateNameAsync(job, template.UnitId);
|
||
var nextRun = await GetNextRunAsync(job, template.NextRun);
|
||
|
||
var updateRequest = new TemplateUpdaterMq
|
||
{
|
||
TemplateId = template.Id,
|
||
JobId = job.Id,
|
||
UnitId = template.UnitId,
|
||
Name = expectedName,
|
||
IsActiveTemplate = template.IsActiveTemplate,
|
||
IsActiveSchedule = template.IsActiveSchedule,
|
||
LastRun = template.LastRun,
|
||
NextRun = nextRun,
|
||
Index = template.Index,
|
||
StatusTypeId = TemplateStatusTypeEnum.Used, // Предполагаем, что используется
|
||
Initiator = initiator,
|
||
UnitsInTemplate = newUnitIds // Передаем обновленный список юнитов
|
||
};
|
||
|
||
await SendTemplateUpdateMessage(updateRequest);
|
||
}
|
||
|
||
private async Task CreateGroupedTemplateAsync(Guid jobId, Guid regionalUnitId, List<Guid> unitIds, int index, HistoryInitiator initiator)
|
||
{
|
||
logger.LogInformation("Создание нового группового шаблона для Job {JobId}, регионального юнита {RegionalUnitId}, Index {Index}, с {Count} юнитами.", jobId, regionalUnitId, index, unitIds.Count);
|
||
|
||
// Предполагаем, что TemplateGeneratorMq может обрабатывать UnitsInTemplate и Index
|
||
var mqRequest = new TemplateGeneratorMq
|
||
{
|
||
JobId = jobId,
|
||
UnitId = regionalUnitId, // UnitId шаблона
|
||
UnitsInTemplate = unitIds, // Юниты для UnitsInTemplate
|
||
Index = index, // Индекс шаблона
|
||
HistoryInitiator = initiator
|
||
};
|
||
|
||
var msg = JsonSerializer.Serialize(mqRequest);
|
||
var result = await mqService.SendAsync(mqSettings.TemplateGenerator, new[] { msg });
|
||
|
||
if (!result.IsSuccess)
|
||
logger.LogError("Ошибка отправки команды создания группового шаблона для Job {JobId}, регионального юнита {RegionalUnitId}, Index {Index}.", jobId, regionalUnitId, index);
|
||
}
|
||
|
||
private async Task<bool> DeactivateTemplateAsync(
|
||
Template template,
|
||
Guid jobId,
|
||
HistoryInitiator initiator)
|
||
{
|
||
if (template.StatusTypeId == TemplateStatusTypeEnum.Updating)
|
||
return true; // уже в обработке
|
||
|
||
logger.LogInformation("Шаблон {TemplateId} (UnitId {UnitId}) → деактивация.",
|
||
template.Id, template.UnitId);
|
||
|
||
template.StatusTypeId = TemplateStatusTypeEnum.Updating;
|
||
template.DateModified = DateTimeOffset.UtcNow;
|
||
|
||
if (!await templateService.CommitAsync(initiator))
|
||
{
|
||
logger.LogError("Не удалось перевести шаблон {TemplateId} в Updating.", template.Id);
|
||
return false;
|
||
}
|
||
|
||
var updateRequest = new TemplateUpdaterMq
|
||
{
|
||
TemplateId = template.Id,
|
||
JobId = jobId,
|
||
UnitId = template.UnitId,
|
||
Name = GetTemplateNameForUnused(template.Name),
|
||
IsActiveTemplate = DefaultUnusedTemplateState,
|
||
IsActiveSchedule = DefaultUnusedScheduleState,
|
||
LastRun = template.LastRun,
|
||
NextRun = template.NextRun,
|
||
Index = template.Index,
|
||
StatusTypeId = TemplateStatusTypeEnum.Unused,
|
||
Initiator = initiator,
|
||
UnitsInTemplate = new List<Guid>()
|
||
};
|
||
|
||
await SendTemplateUpdateMessage(updateRequest);
|
||
return true;
|
||
}
|
||
|
||
private async Task<bool> ReactivateOrRenameTemplateAsync(
|
||
Template template,
|
||
Job job,
|
||
string expectedName,
|
||
HistoryInitiator initiator)
|
||
{
|
||
if (template.StatusTypeId == TemplateStatusTypeEnum.Updating)
|
||
return true;
|
||
|
||
bool needsUpdate = template.Name != expectedName
|
||
|| template.StatusTypeId != TemplateStatusTypeEnum.Used;
|
||
|
||
if (!needsUpdate) return true;
|
||
|
||
logger.LogInformation("Шаблон {TemplateId}: требуется обновление имени или реактивация.", template.Id);
|
||
|
||
template.StatusTypeId = TemplateStatusTypeEnum.Updating;
|
||
template.DateModified = DateTimeOffset.UtcNow;
|
||
|
||
if (!await templateService.CommitAsync(initiator))
|
||
{
|
||
logger.LogError("Не удалось перевести шаблон {TemplateId} в Updating.", template.Id);
|
||
return false;
|
||
}
|
||
|
||
var nextRun = await GetNextRunAsync(job, template.NextRun);
|
||
|
||
var updateRequest = new TemplateUpdaterMq
|
||
{
|
||
TemplateId = template.Id,
|
||
JobId = job.Id,
|
||
UnitId = template.UnitId,
|
||
Name = expectedName,
|
||
IsActiveTemplate = template.IsActiveTemplate,
|
||
IsActiveSchedule = template.IsActiveSchedule,
|
||
LastRun = template.LastRun,
|
||
NextRun = nextRun,
|
||
Index = template.Index,
|
||
StatusTypeId = TemplateStatusTypeEnum.Used,
|
||
Initiator = initiator,
|
||
UnitsInTemplate = template.UnitsInTemplate.Select(t => t.UnitId).ToList()
|
||
};
|
||
|
||
await SendTemplateUpdateMessage(updateRequest);
|
||
return true;
|
||
}
|
||
|
||
private async Task<bool> SendTemplateGeneratorMessageAsync(
|
||
Guid jobId,
|
||
Guid unitId,
|
||
HistoryInitiator initiator)
|
||
{
|
||
logger.LogInformation("Создание нового шаблона для UnitId {UnitId}.", unitId);
|
||
var mqRequest = new TemplateGeneratorMq
|
||
{
|
||
JobId = jobId,
|
||
UnitId = unitId,
|
||
HistoryInitiator = initiator,
|
||
UnitsInTemplate = new List<Guid>()
|
||
};
|
||
|
||
var msg = JsonSerializer.Serialize(mqRequest);
|
||
var result = await mqService.SendAsync(mqSettings.TemplateGenerator, new[] { msg });
|
||
|
||
if (!result.IsSuccess)
|
||
logger.LogError("Ошибка отправки команды создания шаблона для UnitId {UnitId}.", unitId);
|
||
|
||
return result.IsSuccess;
|
||
}
|
||
|
||
private async Task SendTemplateUpdateMessage(TemplateUpdaterMq updateRequest)
|
||
{
|
||
logger.LogDebug("Отправка сообщения в очередь '{Queue}' для шаблона {TemplateId}",
|
||
mqSettings.TemplateUpdater.QueueName, updateRequest.TemplateId);
|
||
|
||
var msg = JsonSerializer.Serialize(updateRequest);
|
||
var result = await mqService.SendAsync(mqSettings.TemplateUpdater, new[] { msg });
|
||
|
||
if (result.IsSuccess)
|
||
{
|
||
logger.LogInformation("Отправлен запрос на обновление шаблона {TemplateId}", updateRequest.TemplateId);
|
||
}
|
||
else
|
||
{
|
||
logger.LogError("Ошибка при отправке запроса на обновление шаблона {TemplateId} в очередь '{Queue}'.",
|
||
updateRequest.TemplateId, mqSettings.TemplateUpdater.QueueName);
|
||
}
|
||
}
|
||
|
||
// --- ИЗМЕНЕННЫЙ МЕТОД: Теперь используется как для простых, так и для групповых шаблонов ---
|
||
private async Task<Template?> TryReuseOneUnusedTemplateAsync(
|
||
Guid jobId, // Используется для логики внутри метода (например, подготовка updateRequest в SyncSimpleTemplatesAsync)
|
||
Guid unitId, // Используется для логики внутри метода (например, подготовка updateRequest в SyncSimpleTemplatesAsync)
|
||
HistoryInitiator initiator,
|
||
int maxAttempts = 3)
|
||
{
|
||
for (int attempt = 1; attempt <= maxAttempts; attempt++)
|
||
{
|
||
try
|
||
{
|
||
var unusedCandidates = await templateService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Unused)
|
||
.OrderBy(t => t.DateModified ?? t.DateCreated)
|
||
.Take(UnusedCandidateBatchSize)
|
||
.ToListAsync();
|
||
|
||
if (!unusedCandidates.Any())
|
||
{
|
||
logger.LogDebug("Нет Unused-шаблонов (попытка {Attempt}).", attempt);
|
||
return null;
|
||
}
|
||
|
||
foreach (var candidate in unusedCandidates)
|
||
{
|
||
var originalStatus = candidate.StatusTypeId;
|
||
var originalModified = candidate.DateModified;
|
||
|
||
try
|
||
{
|
||
candidate.StatusTypeId = TemplateStatusTypeEnum.Updating;
|
||
candidate.DateModified = DateTimeOffset.UtcNow;
|
||
|
||
if (await templateService.CommitAsync(initiator))
|
||
{
|
||
logger.LogInformation("Успешно захвачен шаблон {TemplateId} для переиспользования (попытка {Attempt}).",
|
||
candidate.Id, attempt);
|
||
return candidate; // Возвращаем захваченный шаблон
|
||
}
|
||
|
||
// Откат при неудаче
|
||
candidate.StatusTypeId = originalStatus;
|
||
candidate.DateModified = originalModified;
|
||
}
|
||
catch (Exception ex) when (
|
||
ex is DbUpdateException ||
|
||
ex.InnerException?.Message.Contains("deadlock", StringComparison.OrdinalIgnoreCase) == true ||
|
||
ex.InnerException?.Message.Contains("timeout", StringComparison.OrdinalIgnoreCase) == true)
|
||
{
|
||
logger.LogWarning(ex, "Конфликт при захвате шаблона {TemplateId} (попытка {Attempt}).", candidate.Id, attempt);
|
||
candidate.StatusTypeId = originalStatus;
|
||
candidate.DateModified = originalModified;
|
||
}
|
||
}
|
||
|
||
if (attempt < maxAttempts)
|
||
await Task.Delay(Random.Shared.Next(5, 15) * attempt);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logger.LogError(ex, "Ошибка в попытке захвата (попытка {Attempt}).", attempt);
|
||
if (attempt == maxAttempts) throw;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
private string GetTemplateNameForUnused(string templateName)
|
||
{
|
||
return templateName + "_" + DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
||
}
|
||
|
||
private async Task<Job?> GetJobWithGroupAndAutoControlAsync(Guid jobId)
|
||
{
|
||
return await jobService.Get()
|
||
.AsNoTracking() // Добавлено
|
||
.Include(j => j.Group)
|
||
.ThenInclude(j => j.GroupType)
|
||
.Include(j => j.AutoControl)
|
||
.FirstOrDefaultAsync(j => j.Id == jobId);
|
||
}
|
||
|
||
private async Task<HashSet<Guid>> GetExpectedUnitIdsAsync(Guid jobId)
|
||
{
|
||
var units = await unitFilterService.GetUnitsIdByJobFilterAsync(jobId);
|
||
return units?.ToHashSet() ?? new HashSet<Guid>();
|
||
}
|
||
|
||
private async Task<string> GetNormalizedTemplateNameAsync(Job job, Guid unitId, int? index = null)
|
||
{
|
||
var rawName = await shortcodesService.ApplyShortcodesAsync(job.TemplateNameMask, unitId, job.Id, index);
|
||
return rawName.ToUpper();
|
||
}
|
||
|
||
private async Task<DateTimeOffset> GetNextRunAsync(Job job, DateTimeOffset? currentNextRun = null)
|
||
{
|
||
var now = DateTimeOffset.UtcNow;
|
||
if (currentNextRun.HasValue && currentNextRun.Value > now)
|
||
{
|
||
return currentNextRun.Value;
|
||
}
|
||
|
||
var referenceDate = job.Group?.ReferenceDate ?? now;
|
||
return await esppScheduleTransformService.GetNextDateAsync(job.GroupId, referenceDate);
|
||
}
|
||
}
|
||
} |