feat(dal, templateMatcher): изменена логика работы Shortcodes сервиса в сторону самостоятельной дозагрузки данных из БД, в Template сервис добавлен метод атомарного резервирования шаблона для TemplateMatcher

PARR.API/Contracts/V1/ApiRoutes.cs

@@ -521,6 +521,10 @@
             public const string GetAll = Base + "/shortcodes/";
         }
 
+        public static class ShortcodeApply
+        {
+            public const string Apply = Base + "/shortcodes/apply";
+        }
         public static class RegionalEkPtkGroup
         {
             public const string GetAll = Base + "/regional-ek-ptk-groups/";

PARR.API/Contracts/V1/Requests/ShortcodeApplyRequest.cs

@@ -0,0 +1,8 @@
+namespace PARR.API.Contracts.V1.Requests
+{
+    public class ShortcodeApplyRequest
+    {
+        public Guid TemplateId { get; set; }
+        public required string Content { get; set; }
+    }
+}

PARR.API/Contracts/V1/Responses/ShortcodeApplyResponse.cs

@@ -0,0 +1,7 @@
+namespace PARR.API.Contracts.V1.Responses
+{
+    public class ShortcodeApplyResponse
+    {
+        public required string Content { get; set; }
+    }
+}

PARR.API/Controllers/V1/ShortcodeApplyController.cs

@@ -0,0 +1,60 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using PARR.API.Contracts.V1;
+using PARR.API.Contracts.V1.Requests;
+using PARR.API.Contracts.V1.Responses;
+using PARR.API.Contracts.V1.Responses.Base;
+using PARR.API.Controllers.V1.Base;
+using PARR.DAL.DomainServices.Shortcodes;
+using PARR.DAL.Services.Interfaces;
+
+namespace PARR.API.Controllers.V1
+{
+    public class ShortcodeApplyController : BaseApiController
+    {
+        private readonly ILogger<ShortcodeController> logger;
+        private readonly IShortcodesService shortcodesService;
+        private readonly ITemplateService templateService;
+
+        public ShortcodeApplyController(
+            ILogger<ShortcodeController> logger,
+            IShortcodesService shortcodesService,
+            ITemplateService templateService
+            )
+        {
+            this.logger = logger;
+            this.shortcodesService = shortcodesService;
+            this.templateService = templateService;
+        }
+
+
+        /// <summary>
+        /// Получить список всех переменных составляющих
+        /// </summary>
+        /// <returns></returns>
+        [HttpPost(ApiRoutes.ShortcodeApply.Apply)]
+        public async Task<IActionResult> Apply([FromBody] ShortcodeApplyRequest request)
+        {
+            var template = await templateService.Get()
+                                .Include(t => t.Unit)
+                                .Include(t => t.UnitsInTemplate)
+                                .Include(t => t.Unit)
+                                .Include(t => t.Job)
+                                    .ThenInclude(t => t!.Group)
+                                        .ThenInclude(t => t!.GroupType)
+                                .Include(t => t.Job)
+                                    .ThenInclude(t => t!.Tnk)
+                                .AsNoTracking()
+                                .FirstOrDefaultAsync(t => t.Id == request.TemplateId);
+
+            if (template == null)
+                return BadRequest(new Response(false, new List<ErrorModel> { new ErrorModel { FieldName = nameof(request.TemplateId), Message = $"Шаблон имеющий Id = {request.TemplateId} не найден" } }));
+
+            var aplyingShortCodes = await shortcodesService.ApplyShortcodesAsync(request.Content, template);
+
+            var response = new ShortcodeApplyResponse { Content = aplyingShortCodes };
+
+            return Ok(new Response<ShortcodeApplyResponse>(response, true));
+        }
+    }
+}

PARR.Constants/ShortcodeTypeEnum.cs

@@ -6,8 +6,10 @@ namespace PARR.Constants
     public enum ShortcodeTypeEnum
     {
         Static,
-        Standart,
+        Standard,
         Relationship,
-        FieldValue
+        FieldValue,
+        GroupValue,
+        Transform
     }
 }

PARR.DAL/DomainServices/Implementations/UnitFilterService.cs

@@ -13,7 +13,7 @@ namespace PARR.DAL.DomainServices.Implementations
     internal class UnitFilterService : IUnitFilterService
     {
 #if DEBUG
-        private readonly Guid targetUnitId = Guid.Parse("6c019569-ecba-4d9a-9cdf-cdc1dea93925");
+        private readonly Guid targetUnitId = Guid.Parse("87fc4c36-1ea8-4163-983f-1605fee1de99");
 #endif
 
         private readonly ILogger<UnitFilterService> logger;

PARR.DAL/DomainServices/Shortcodes/IShortcodesService.cs

@@ -1,16 +1,12 @@
 using PARR.DAL.DomainModels;
-using PARR.DAL.DomainServices.Shortcodes.Models;
 using PARR.DAL.Models;
+using System.Runtime.CompilerServices;
 
 namespace PARR.DAL.DomainServices.Shortcodes
 {
     public interface IShortcodesService
     {
-        Task<string> ApplyShortcodesAsync(string str, TemplateForShortcodes template);
-
-        Task<string> ApplyShortcodesAsync(string str, Template template);
-
-        //        bool IsAnyShortcodes(string str);
+        Task<string> ApplyShortcodesAsync(string str, Template template, [CallerMemberName] string? caller = null);
 
         Task<List<ShortcodeInfoDto>> GetAvailableShortcodesAsync();
     }

PARR.DAL/DomainServices/Shortcodes/Models/JobForShortcodes.cs

@@ -1,10 +0,0 @@
-namespace PARR.DAL.DomainServices.Shortcodes.Models
-{
-    public class JobForShortcodes
-    {
-        public JobGroupForShortcodes? Group { get; set; }
-        public TnkForShortcodes? Tnk { get; set; }
-        public string WorkName { get; set; } = string.Empty;
-        public string Name { get; set; } = string.Empty;
-    }
-}

PARR.DAL/DomainServices/Shortcodes/Models/JobGroupForShortcodes.cs

@@ -1,10 +0,0 @@
-namespace PARR.DAL.DomainServices.Shortcodes.Models
-{
-    public class JobGroupForShortcodes
-    {
-        public Guid Id { get; set; }
-        public Guid? GroupingUnitFieldId { get; set; }
-        public JobGroupTypeForShortcodes? GroupType { get; set; }
-        public string GroupName { get; set; } = string.Empty;
-    }
-}

PARR.DAL/DomainServices/Shortcodes/Models/JobGroupTypeForShortcodes.cs

@@ -1,9 +0,0 @@
-using PARR.DAL.Contracts;
-
-namespace PARR.DAL.DomainServices.Shortcodes.Models
-{
-    public class JobGroupTypeForShortcodes
-    {
-        public JobGroupTypesEnum Code { get; set; }
-    }
-}

PARR.DAL/DomainServices/Shortcodes/Models/TemplateForShortcodes.cs

@@ -1,13 +0,0 @@
-namespace PARR.DAL.DomainServices.Shortcodes.Models
-{
-    public class TemplateForShortcodes
-    {
-        public Guid Id { get; set; }
-        public int? Index { get; set; }
-        public Guid JobId { get; set; }
-        public Guid UnitId { get; set; }
-
-        public JobForShortcodes? Job { get; set; }
-        public List<UnitInTemplateForShortcodes> UnitsInTemplate { get; set; } = new();
-    }
-}

PARR.DAL/DomainServices/Shortcodes/Models/TnkForShortcodes.cs

@@ -1,8 +0,0 @@
-namespace PARR.DAL.DomainServices.Shortcodes.Models
-{
-    public class TnkForShortcodes
-    {
-        public string Name { get; set; } = string.Empty;
-        public string ShortName { get; set; } = string.Empty;
-    }
-}

PARR.DAL/DomainServices/Shortcodes/Models/UnitInTemplateForShortcodes.cs

@@ -1,7 +0,0 @@
-namespace PARR.DAL.DomainServices.Shortcodes.Models
-{
-    public class UnitInTemplateForShortcodes
-    {
-        public Guid UnitId { get; set; }
-    }
-}

PARR.DAL/DomainServices/Shortcodes/ShortcodesService.cs

@@ -7,23 +7,42 @@ using PARR.DAL.DomainModels;
 using PARR.DAL.DomainServices.Interfaces;
 using PARR.DAL.DomainServices.Shortcodes.Models;
 using PARR.DAL.Models;
-using PARR.DAL.Models.Unit;
+using PARR.DAL.Models.Job;
 using PARR.DAL.Services.Interfaces;
 using PARR.DAL.Services.Interfaces.Job;
 using PARR.DAL.Services.Interfaces.Unit;
+using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 
 namespace PARR.DAL.DomainServices.Shortcodes
 {
+    /// <summary>
+    /// Сервис для подстановки шорткодов в строке на основе данных шаблона.
+    /// </summary>
     internal class ShortcodesService : IShortcodesService
     {
-        private const string shortcodePattern = "%[^%\\s]+%";
-        private const string maxShortcodePattern = @"%МАКС:([а-яА-Яa-zA-Z0-9_]+)%";
-        private const string lettersShortcodePattern = @"%БУКВЫ:([^%]+)%";
+        private const string MissingJobWarningMsg =
+            "[{Caller}] Шаблон {TemplateId} не содержит Job в переданных данных. Данные будут догружены из БД. " +
+            "Рекомендуется обновить запрос шаблона с Include(j => j.Job).";
 
-        private static readonly HashSet<string> SupportedShortcodes = new(StringComparer.OrdinalIgnoreCase)
+        private const string MissingIncludesWarningMsg =
+            "[{Caller}] Шаблон {TemplateId} содержит Job, но не хватает данных для шорткодов: {Shortcodes}. " +
+            "Отсутствуют Include: {MissingIncludes}. Данные будут догружены из БД. " +
+            "Рекомендуется обновить запрос шаблона.";
+
+        private const string MissingUnitNameWarningMsg =
+            "[{Caller}] Шаблон {TemplateId} не содержит Unit.Name в переданных данных. Данные будут догружены из БД. " +
+            "Рекомендуется обновить запрос шаблона с Include(t => t.Unit).";
+
+        private const int MaxIterations = 3;
+        private const string NoContent = "Нет данных";
+        private static readonly Regex GeneralShortcodeRegex = new(@"%[^%\s]+%", RegexOptions.Compiled);
+        private static readonly Regex MaxShortcodeRegex = new(@"%МАКС:([а-яА-Яa-zA-Z0-9_]+)%", RegexOptions.Compiled);
+        private static readonly Regex LettersShortcodeRegex = new(@"%БУКВЫ:([^%]+)%", RegexOptions.Compiled);
+
+        private static readonly HashSet<string> SupportedStandardShortcodes = new(StringComparer.OrdinalIgnoreCase)
         {
-            "%ЭК%", "%ГРУППА_РАБОТ%", "%РАБОТА%", "%ТНК%", "%СВЯЗИ%", "%ТНК-КРАТКО%", "%СВЯЗИ-ПН%", "%ИНДЕКС%"
+            "%ЭК%", "%ГРУППА_РАБОТ%", "%РАБОТА%", "%ТНК%", "%ТНК-КРАТКО%", "%ТИКТАК%"
         };
 
         private readonly ILogger<ShortcodesService> logger;
@@ -36,6 +55,43 @@ namespace PARR.DAL.DomainServices.Shortcodes
         private readonly IRedisCacheService cacheService;
         private readonly IUnitFilterService unitFilterService;
 
+        // Используем record struct вместо class
+        private record class TemplateForShortcodes(
+            Guid Id,
+            int? Index,
+            Guid JobId,
+            Guid UnitId,
+            JobForShortcodes? Job,
+            List<UnitInTemplateForShortcodes> UnitsInTemplate
+        );
+
+        private record class JobForShortcodes(
+            JobGroupForShortcodes? Group,
+            TnkForShortcodes? Tnk,
+            string WorkName,
+            string Name
+        );
+
+        private record class JobGroupForShortcodes(
+            Guid Id,
+            Guid? GroupingUnitFieldId,
+            JobGroupTypeForShortcodes? GroupType,
+            string GroupName
+        );
+
+        private record class JobGroupTypeForShortcodes(
+            JobGroupTypesEnum Code
+        );
+
+        private record class TnkForShortcodes(
+            string Name,
+            string ShortName
+        );
+
+        private record class UnitInTemplateForShortcodes(
+            Guid UnitId
+        );
+
         public ShortcodesService(
             ILogger<ShortcodesService> logger,
             SettingsFromDb settingsFromDb,
@@ -59,229 +115,380 @@ namespace PARR.DAL.DomainServices.Shortcodes
             this.unitFilterService = unitFilterService;
         }
 
-        public Task<string> ApplyShortcodesAsync(string str, Template template)
+        /// <summary>
+        /// Подставляет шорткоды в строке на основе данных шаблона.
+        /// </summary>
+        /// <param name="str">Строка с шорткодами</param>
+        /// <param name="template">Шаблон, из которого берутся данные</param>
+        /// <returns>Строка с подставленными значениями</returns>
+        public async Task<string> ApplyShortcodesAsync(string str, Template template, [CallerMemberName] string? caller = null)
         {
-            // Построим TemplateForShortcodes из уже загруженного template
-            var templateForShortcodes = new TemplateForShortcodes
-            {
-                Id = template.Id,
-                Index = template.Index,
-                JobId = template.JobId,
-                UnitId = template.UnitId,
-                Job = template.Job == null ? null : new JobForShortcodes
-                {
-                    Group = template.Job.Group == null ? null : new JobGroupForShortcodes
-                    {
-                        Id = template.Job.GroupId,
-                        GroupingUnitFieldId = template.Job.Group.GroupingUnitFieldId,
-                        GroupType = template.Job.Group.GroupType == null ? null : new JobGroupTypeForShortcodes
-                        {
-                            Code = template.Job.Group.GroupType.Code
-                        },
-                        GroupName = template.Job.Group.GroupName
-                    },
-                    Tnk = template.Job.Tnk == null ? null : new TnkForShortcodes
-                    {
-                        Name = template.Job.Tnk.Name,
-                        ShortName = template.Job.Tnk.ShortName
-                    },
-                    WorkName = template.Job.WorkName,
-                    Name = template.Job.Name
-                },
-                UnitsInTemplate = template.UnitsInTemplate?.Select(uit => new UnitInTemplateForShortcodes { UnitId = uit.UnitId }).ToList() ?? new List<UnitInTemplateForShortcodes>()
-            };
+            if (string.IsNullOrEmpty(str)) return str;
+            if (template == null) throw new ArgumentNullException(nameof(template));
 
-            return ApplyShortcodesAsync(str, templateForShortcodes);
-        }
+            var callerName = caller ?? "Unknown";
 
+            logger.LogDebug("[{Caller}] Начата подстановка шорткодов. Вход: '{Input}', templateId={TemplateId}", callerName, str, template.Id);
 
-        //todo: сделать private в перспективе
-        public async Task<string> ApplyShortcodesAsync(string str, TemplateForShortcodes template)
-        {
-            if (!IsAnyShortcodes(str))
-            {
-                logger.LogDebug("Строка не содержит шорткодов: {str}", str);
-                return str;
-            }
-
-            logger.LogDebug("Начата подстановка шорткодов. Вход: '{Input}', templateId={TemplateId}, index={Index}", str, template.Id, template.Index);
-
-            var job = template.Job;
-            if (job == null)
-            {
-                logger.LogError("Шаблон {TemplateId} не содержит Job. Подстановка прервана.", template.Id);
-                return str;
-            }
-
-            var unit = await unitService.Get().AsNoTracking().FirstOrDefaultAsync(u => u.Id == template.UnitId);
-
-            if (unit == null || string.IsNullOrEmpty(str))
-            {
-                logger.LogError("Переданы некорректные данные для подстановки динамических записей");
-                return str;
-            }
-
-            var resultName = str;
-            var shortcodesInMask = GetShortCodes(resultName);
-
-            // 1. Статические константы
-            var nameConstants = settingsFromDb.TemplateNameConstantPartsList;
-            if (shortcodesInMask.Any(m => nameConstants.Any(c => $"%{c.Name}%".Equals(m.Value, StringComparison.OrdinalIgnoreCase))))
-            {
-                resultName = ReplaceConstants(nameConstants, resultName);
-            }
-
-            // 2. Стандартные шорткоды — с поддержкой вложенных (%РАБОТА% → "Мониторинг | %ЭК%")
-            const int MaxStandardIterations = 3;
+            var result = str;
             var iteration = 0;
 
-            while (iteration < MaxStandardIterations)
+            while (iteration < MaxIterations)
             {
-                var remainingShortcodes = GetShortCodes(resultName)
-                    .Select(m => m.Value)
-                    .Where(s => SupportedShortcodes.Contains(s))
-                    .ToList();
+                var shortcodes = GetShortCodes(result).Select(m => m.Value).ToList();
+                if (!shortcodes.Any()) break;
 
-                if (!remainingShortcodes.Any())
-                    break;
+                // Подготавливаем данные с догрузкой при необходимости
+                var data = await PrepareTemplateDataAsync(template, shortcodes, callerName).ConfigureAwait(false);
+
+                var oldResult = result;
+
+                // Подстановка всех типов шорткодов
+                result = await ApplyAllShortcodesOnceAsync(result, data, shortcodes, callerName).ConfigureAwait(false);
 
-                var oldResult = resultName;
-                resultName = ReplaceStandardShortcodes(job, unit, resultName, template.Index);
                 iteration++;
 
-                if (resultName == oldResult)
+                if (result == oldResult) break;
+            }
+
+            logger.LogDebug("[{Caller}] Подстановка завершена. Результат: '{Result}'", callerName, result);
+            return result;
+        }
+
+        private async Task<TemplateForShortcodes> PrepareTemplateDataAsync(Template template, List<string> shortcodes, string caller)
+        {
+            var data = new TemplateForShortcodes(
+                Id: template.Id,
+                Index: template.Index,
+                JobId: template.JobId,
+                UnitId: template.UnitId,
+                Job: null,
+                UnitsInTemplate: template.UnitsInTemplate?.Select(uit => new UnitInTemplateForShortcodes(uit.UnitId)).ToList() ?? new List<UnitInTemplateForShortcodes>()
+            );
+
+            // Загружаем Unit.Name
+            var unitName = template.Unit?.Name ?? await GetUnitNameAsyncWithWarning(template, shortcodes, caller).ConfigureAwait(false);
+
+            // Проверяем, нужны ли данные Job
+            if (!NeedsJobForShortcodes(shortcodes))
+            {
+                // Всё равно создаём пустой JobForShortcodes, чтобы не было null
+                data = data with { Job = new JobForShortcodes(null, null, string.Empty, string.Empty) };
+                return data;
+            }
+
+            if (template.Job == null)
+            {
+                logger.LogWarning(MissingJobWarningMsg, caller, template.Id);
+                var jobData = await LoadJobForShortcodesAsync(template.JobId, shortcodes, caller).ConfigureAwait(false);
+                return data with { Job = jobData };
+            }
+            else
+            {
+                var missingIncludes = GetMissingIncludesForShortcodes(shortcodes, template.Job);
+                if (missingIncludes.Any())
                 {
-                    logger.LogDebug("Замена стандартных шорткодов не изменила строку на итерации {Iteration}. Останов.", iteration);
-                    break;
-                }
-            }
+                    var problematicShortcodes = shortcodes.Where(sc =>
+                        (sc.Equals("%ГРУППА_РАБОТ%", StringComparison.OrdinalIgnoreCase) && template.Job.Group == null) ||
+                        (sc.StartsWith("%МАКС:", StringComparison.OrdinalIgnoreCase) && template.Job.Group?.GroupType == null) ||
+                        (sc.Equals("%ГР_ПОЛЕ-ПН%", StringComparison.OrdinalIgnoreCase) && template.Job.Group?.GroupType == null) ||
+                        (sc.Equals("%ИНДЕКС%", StringComparison.OrdinalIgnoreCase) && template.Job.Group?.GroupType == null) ||
+                        ((sc.Equals("%ТНК%", StringComparison.OrdinalIgnoreCase) || sc.Equals("%ТНК-КРАТКО%", StringComparison.OrdinalIgnoreCase)) && template.Job.Tnk == null)
+                    ).ToList();
 
-            if (iteration >= MaxStandardIterations)
-            {
-                logger.LogWarning(
-                    "Достигнуто максимальное число итераций ({Max}) при замене стандартных шорткодов. Текущий результат: {Result}",
-                    MaxStandardIterations, resultName);
-            }
+                    logger.LogWarning(MissingIncludesWarningMsg, caller, template.Id, string.Join(", ", problematicShortcodes), string.Join(" ", missingIncludes));
 
-            // 2.5. %МАКС:FIELD% — только для групповых job (JobGroup.Type == Group)
-            if (job.Group != null && job.Group.GroupType != null && job.Group.GroupType!.Code == JobGroupTypesEnum.Group)
-            {
-                var maxShortcodes = Regex.Matches(resultName, maxShortcodePattern);
-                if (maxShortcodes.Count > 0)
-                {
-                    resultName = await ReplaceMaxShortcodesAsync(job.Group.Id, template.UnitId, resultName, maxShortcodes);
-                }
-            }
-
-            // 2.6. %БУКВЫ:FIELD% — извлекает только буквы из значения поля
-            var lettersShortcodes = Regex.Matches(resultName, lettersShortcodePattern);
-            if (lettersShortcodes.Count > 0)
-            {
-                resultName = await ReplaceLettersShortcodesAsync(template.UnitId, resultName, lettersShortcodes);
-            }
-
-            // 2.7. %ГР_ПОЛЕ-ПН% — нумерованный список UnitsInTemplate с GroupingUnitFieldId, отсортированный по имени юнита
-            if (shortcodesInMask.Any(m => string.Equals(m.Value, "%ГР_ПОЛЕ-ПН%", StringComparison.OrdinalIgnoreCase)))
-            {
-                var unitsInTemplate = template.UnitsInTemplate;
-                if (unitsInTemplate == null || !unitsInTemplate.Any())
-                {
-                    logger.LogDebug("Шаблон {TemplateId} не содержит UnitsInTemplate. %ГР_ПОЛЕ-ПН% заменён на пустую строку.", template.Id);
-                    resultName = Regex.Replace(resultName, "%ГР_ПОЛЕ-ПН%", "", RegexOptions.IgnoreCase);
+                    var jobData = await LoadJobForShortcodesAsync(template.JobId, shortcodes, caller).ConfigureAwait(false);
+                    return data with { Job = jobData };
                 }
                 else
                 {
-                    var unitIds = unitsInTemplate.Select(uit => uit.UnitId).ToList();
+                    var jobData = MapJobForShortcodes(template.Job);
+                    return data with { Job = jobData };
+                }
+            }
+        }
 
-                    var units = await unitService.Get()
-                        .AsNoTracking()
-                        .Where(u => unitIds.Contains(u.Id))
-                        .ToListAsync();
+        private static bool NeedsJobForShortcodes(List<string> shortcodes)
+        {
+            return shortcodes.Any(sc =>
+                sc != "%ЭК%" && // %ЭК% не требует Job
+                (SupportedStandardShortcodes.Contains(sc) ||
+                 sc.StartsWith("%МАКС:", StringComparison.OrdinalIgnoreCase) ||
+                 sc.Equals("%ГР_ПОЛЕ-ПН%", StringComparison.OrdinalIgnoreCase) ||
+                 sc.Equals("%ИНДЕКС%", StringComparison.OrdinalIgnoreCase) ||
+                 sc.Equals("%СВЯЗИ%", StringComparison.OrdinalIgnoreCase) ||
+                 sc.Equals("%СВЯЗИ-ПН%", StringComparison.OrdinalIgnoreCase)));
+        }
 
-                    // Словарь: UnitId -> Unit (для быстрого поиска)
-                    var unitDict = units.ToDictionary(u => u.Id, u => u);
+        private static List<string> GetMissingIncludesForShortcodes(List<string> shortcodes, Job? job)
+        {
+            var missing = new List<string>();
 
-                    var groupingFieldId = job.Group?.GroupingUnitFieldId;
-                    Dictionary<Guid, string> valuesByUnit = new();
+            if (shortcodes.Any(sc =>
+                    sc.Equals("%ГРУППА_РАБОТ%", StringComparison.OrdinalIgnoreCase) ||
+                    sc.StartsWith("%МАКС:", StringComparison.OrdinalIgnoreCase) ||
+                    sc.Equals("%ГР_ПОЛЕ-ПН%", StringComparison.OrdinalIgnoreCase) ||
+                    sc.Equals("%ИНДЕКС%", StringComparison.OrdinalIgnoreCase))
+                && job?.Group == null)
+            {
+                missing.Add(".Include(j => j.Group)");
+            }
 
-                    if (groupingFieldId.HasValue)
-                    {
-                        var fieldValues = await unitInValueService.Get()
-                            .AsNoTracking()
-                            .Include(uv => uv.Value)
-                            .Where(uv =>
-                                uv.FieldId == groupingFieldId.Value &&
-                                unitIds.Contains(uv.UnitId) &&
-                                uv.Value != null &&
-                                !string.IsNullOrWhiteSpace(uv.Value.Value))
-                            .Select(uv => new { uv.UnitId, Value = uv.Value!.Value })
-                            .ToListAsync();
+            if (shortcodes.Any(sc =>
+                    sc.StartsWith("%МАКС:", StringComparison.OrdinalIgnoreCase) ||
+                    sc.Equals("%ГР_ПОЛЕ-ПН%", StringComparison.OrdinalIgnoreCase) ||
+                    sc.Equals("%ИНДЕКС%", StringComparison.OrdinalIgnoreCase))
+                && job?.Group?.GroupType == null)
+            {
+                missing.Add(".ThenInclude(g => g.GroupType)");
+            }
 
-                        valuesByUnit = fieldValues
-                            .GroupBy(x => x.UnitId)
-                            .ToDictionary(
-                                g => g.Key,
-                                g => string.Join(", ", g.Select(v => v.Value).OrderBy(v => v))
-                            );
-                    }
+            if (shortcodes.Any(sc =>
+                    sc.Equals("%ТНК%", StringComparison.OrdinalIgnoreCase) ||
+                    sc.Equals("%ТНК-КРАТКО%", StringComparison.OrdinalIgnoreCase))
+                && job?.Tnk == null)
+            {
+                missing.Add(".Include(j => j.Tnk)");
+            }
 
-                    // Сортируем UnitsInTemplate по имени юнита
-                    var sortedUnitsInTemplate = unitsInTemplate
-                        .OrderBy(uit => unitDict.TryGetValue(uit.UnitId, out var unit) ? unit.Name : $"(UnitId={uit.UnitId})")
-                        .ToList();
+            return missing;
+        }
 
-                    var lines = sortedUnitsInTemplate
-                        .Select((uit, indexInList) =>
-                        {
-                            var unitInList = unitDict.TryGetValue(uit.UnitId, out var unit) ? unit : null;
-                            var unitName = unitInList?.Name ?? $"(UnitId={uit.UnitId})";
-                            var valuesStr = valuesByUnit.TryGetValue(uit.UnitId, out var vals) ? vals : "";
-                            return $"{indexInList + 1}. {unitName} ({valuesStr})";
-                        })
-                        .ToList();
+        private async Task<string> GetUnitNameAsyncWithWarning(Template template, List<string> shortcodes, string caller)
+        {
+            if (shortcodes.Any(sc => sc.Equals("%ЭК%", StringComparison.OrdinalIgnoreCase)))
+            {
+                logger.LogWarning(MissingUnitNameWarningMsg, caller, template.Id);
+            }
 
-                    var resultText = string.Join("\n", lines);
-                    resultName = Regex.Replace(resultName, "%ГР_ПОЛЕ-ПН%", resultText, RegexOptions.IgnoreCase);
+            var unit = await unitService.Get().AsNoTracking().FirstOrDefaultAsync(u => u.Id == template.UnitId).ConfigureAwait(false);
+            if (unit == null || string.IsNullOrEmpty(unit.Name))
+                throw new InvalidOperationException($"Unit {template.UnitId} не найден или не содержит Name.");
+
+            return unit.Name;
+        }
+
+        private JobForShortcodes MapJobForShortcodes(Job job)
+        {
+            return new JobForShortcodes(
+                Group: job.Group == null ? null : new JobGroupForShortcodes(
+                    Id: job.Group.Id,
+                    GroupingUnitFieldId: job.Group.GroupingUnitFieldId,
+                    GroupName: job.Group.GroupName ?? string.Empty,
+                    GroupType: job.Group.GroupType == null ? null : new JobGroupTypeForShortcodes(job.Group.GroupType.Code)
+                ),
+                Tnk: job.Tnk == null ? null : new TnkForShortcodes(
+                    Name: job.Tnk.Name ?? string.Empty,
+                    ShortName: job.Tnk.ShortName ?? string.Empty
+                ),
+                WorkName: job.WorkName ?? string.Empty,
+                Name: job.Name ?? string.Empty
+            );
+        }
+
+        private async Task<JobForShortcodes> LoadJobForShortcodesAsync(Guid jobId, List<string> shortcodes, string caller)
+        {
+            var query = jobService.Get().AsNoTracking();
+
+            // Всегда загружаем Group и GroupType, если нужны групповые шорткоды
+            if (shortcodes.Any(sc =>
+                sc.StartsWith("%МАКС:", StringComparison.OrdinalIgnoreCase) ||
+                sc.Equals("%ГР_ПОЛЕ-ПН%", StringComparison.OrdinalIgnoreCase) ||
+                sc.Equals("%ИНДЕКС%", StringComparison.OrdinalIgnoreCase)))
+            {
+                query = query
+                    .Include(j => j.Group)
+                        .ThenInclude(g => g!.GroupType);
+            }
+
+            // Для стандартных шорткодов тоже может понадобиться Group.GroupName
+            if (shortcodes.Any(sc => sc.Equals("%ГРУППА_РАБОТ%", StringComparison.OrdinalIgnoreCase)))
+            {
+                query = query
+                    .Include(j => j.Group);
+            }
+
+            // Для Tnk
+            if (shortcodes.Any(sc =>
+                sc.Equals("%ТНК%", StringComparison.OrdinalIgnoreCase) ||
+                sc.Equals("%ТНК-КРАТКО%", StringComparison.OrdinalIgnoreCase)))
+            {
+                query = query
+                    .Include(j => j.Tnk);
+            }
+
+            var job = await query.FirstOrDefaultAsync(j => j.Id == jobId).ConfigureAwait(false);
+            if (job == null)
+                throw new InvalidOperationException($"Job {jobId} не найден.");
+
+            return MapJobForShortcodes(job);
+        }
+
+        private async Task<string> ApplyAllShortcodesOnceAsync(string str, TemplateForShortcodes data, List<string> shortcodesInMask, string caller)
+        {
+            var result = str;
+
+            // 1. Константы
+            var nameConstants = settingsFromDb.TemplateNameConstantPartsList;
+            if (shortcodesInMask.Any(m => nameConstants.Any(c => $"%{c.Name}%".Equals(m, StringComparison.OrdinalIgnoreCase))))
+            {
+                result = ReplaceConstants(nameConstants, result);
+            }
+
+            // 2. Стандартные
+            var hasStandardShortcodes = shortcodesInMask.Any(m => SupportedStandardShortcodes.Contains(m));
+            if (hasStandardShortcodes)
+            {
+                var unitName = await GetUnitNameForTemplateAsync(data.UnitId).ConfigureAwait(false);
+                result = ReplaceStandardShortcodes(data.Job, unitName, result);
+            }
+
+            // 3. GroupJob: %ИНДЕКС%, %МАКС:..., %ГР_ПОЛЕ-ПН%
+            if (shortcodesInMask.Any(m => string.Equals(m, "%ИНДЕКС%", StringComparison.OrdinalIgnoreCase)))
+            {
+                result = ReplaceSingleShortcode(result, "%ИНДЕКС%", data.Index?.ToString());
+            }
+
+            if (data.Job?.Group?.GroupType?.Code == JobGroupTypesEnum.Group)
+            {
+                var maxShortcodes = MaxShortcodeRegex.Matches(result);
+                if (maxShortcodes.Count > 0)
+                {
+                    result = await ReplaceMaxShortcodesAsync(data.Job.Group.Id, data.UnitId, result, maxShortcodes, caller).ConfigureAwait(false);
                 }
             }
 
-            // 3. %СВЯЗИ% или %СВЯЗИ-ПН% (если всё ещё зависят от jobId/unitId)
+            if (shortcodesInMask.Any(m => string.Equals(m, "%ГР_ПОЛЕ-ПН%", StringComparison.OrdinalIgnoreCase)))
+            {
+                if (data.Job?.Group == null)
+                {
+                    logger.LogWarning("[{Caller}] Job не содержит Group, необходимый для %ГР_ПОЛЕ-ПН%. Шорткод пропущен.", caller);
+                }
+                else
+                {
+                    List<Guid> unitIds;
+                    bool wasLoadedFromDb = false;
+
+                    if (data.UnitsInTemplate.Count == 0)
+                    {
+                        logger.LogWarning(
+                            "[{Caller}] Template {TemplateId} не содержит UnitsInTemplate. Данные будут догружены из БД. " +
+                            "Рекомендуется обновить запрос с Include(t => t.UnitsInTemplate).",
+                            caller, data.Id);
+
+                        var fullTemplate = await templateService.Get()
+                            .AsNoTracking()
+                            .Include(t => t.UnitsInTemplate)
+                            .FirstOrDefaultAsync(t => t.Id == data.Id)
+                            .ConfigureAwait(false);
+
+                        unitIds = fullTemplate?.UnitsInTemplate?.Select(uit => uit.UnitId).ToList() ?? new List<Guid>();
+                        wasLoadedFromDb = true;
+                    }
+                    else
+                    {
+                        unitIds = data.UnitsInTemplate.Select(uit => uit.UnitId).ToList();
+                    }
+
+                    if (unitIds.Count == 0)
+                    {
+                        logger.LogDebug("[{Caller}] Нет UnitsInTemplate для шаблона {TemplateId}. %ГР_ПОЛЕ-ПН% заменён на пустую строку.", caller, data.Id);
+                        result = Regex.Replace(result, "%ГР_ПОЛЕ-ПН%", "", RegexOptions.IgnoreCase);
+                    }
+                    else
+                    {
+                        var units = await unitService.Get()
+                            .AsNoTracking()
+                            .Where(u => unitIds.Contains(u.Id))
+                            .ToDictionaryAsync(u => u.Id, u => u).ConfigureAwait(false);
+
+                        var groupingFieldId = data.Job.Group.GroupingUnitFieldId;
+                        Dictionary<Guid, string> valuesByUnit = new();
+
+                        if (groupingFieldId.HasValue)
+                        {
+                            var fieldValues = await unitInValueService.Get()
+                                .AsNoTracking()
+                                .Include(uv => uv.Value)
+                                .Where(uv =>
+                                    uv.FieldId == groupingFieldId.Value &&
+                                    unitIds.Contains(uv.UnitId) &&
+                                    uv.Value != null &&
+                                    !string.IsNullOrWhiteSpace(uv.Value.Value))
+                                .Select(uv => new { uv.UnitId, Value = uv.Value!.Value })
+                                .ToListAsync().ConfigureAwait(false);
+
+                            valuesByUnit = fieldValues
+                                .GroupBy(x => x.UnitId)
+                                .ToDictionary(g => g.Key, g => string.Join(", ", g.OrderBy(v => v.Value).Select(v => v.Value)));
+                        }
+
+                        var actualUnitsInTemplate = unitIds.Select(id => new UnitInTemplateForShortcodes(id)).ToList();
+
+                        var sortedUnitsInTemplate = actualUnitsInTemplate
+                            .OrderBy(uit => units.TryGetValue(uit.UnitId, out var u) ? u.Name : uit.UnitId.ToString())
+                            .ToList();
+
+                        var lines = sortedUnitsInTemplate
+                            .Select((uit, i) =>
+                            {
+                                var unitName = units.TryGetValue(uit.UnitId, out var u) ? u.Name : $"(UnitId={uit.UnitId})";
+                                var valuesStr = valuesByUnit.TryGetValue(uit.UnitId, out var vals) ? vals : "";
+                                return $"{i + 1}. {unitName} ({valuesStr})";
+                            });
+
+                        result = Regex.Replace(result, "%ГР_ПОЛЕ-ПН%", string.Join("\n", lines), RegexOptions.IgnoreCase);
+                    }
+                }
+            }
+
+            // 4. Transform: %БУКВЫ:...
+            var lettersShortcodes = LettersShortcodeRegex.Matches(result);
+            if (lettersShortcodes.Count > 0)
+            {
+                result = await ReplaceLettersShortcodesAsync(data.UnitId, result, lettersShortcodes, caller).ConfigureAwait(false);
+            }
+
+            // 5. %СВЯЗИ% и %СВЯЗИ-ПН%
             List<string>? relatedUnitNames = null;
-
-            if (shortcodesInMask.Any(m => string.Equals(m.Value, "%СВЯЗИ%", StringComparison.OrdinalIgnoreCase)))
+            if (shortcodesInMask.Any(m => string.Equals(m, "%СВЯЗИ%", StringComparison.OrdinalIgnoreCase)))
             {
-                relatedUnitNames ??= await unitFilterService.GetRelatedUnitNamesAsync(template.JobId, template.UnitId);
-                var linksText = string.Join("\n", relatedUnitNames);
-                resultName = Regex.Replace(resultName, "%СВЯЗИ%", linksText, RegexOptions.IgnoreCase);
+                if (data.Job != null)
+                {
+                    relatedUnitNames ??= await unitFilterService.GetRelatedUnitNamesAsync(data.JobId, data.UnitId).ConfigureAwait(false);
+                    result = Regex.Replace(result, "%СВЯЗИ%", string.Join("\n", relatedUnitNames), RegexOptions.IgnoreCase);
+                }
+            }
+            if (shortcodesInMask.Any(m => string.Equals(m, "%СВЯЗИ-ПН%", StringComparison.OrdinalIgnoreCase)))
+            {
+                if (data.Job != null)
+                {
+                    relatedUnitNames ??= await unitFilterService.GetRelatedUnitNamesAsync(data.JobId, data.UnitId).ConfigureAwait(false);
+                    var numbered = relatedUnitNames.Select((name, i) => $"{i + 1}. {name}");
+                    result = Regex.Replace(result, "%СВЯЗИ-ПН%", string.Join("\n", numbered), RegexOptions.IgnoreCase);
+                }
             }
 
-            if (shortcodesInMask.Any(m => string.Equals(m.Value, "%СВЯЗИ-ПН%", StringComparison.OrdinalIgnoreCase)))
-            {
-                relatedUnitNames ??= await unitFilterService.GetRelatedUnitNamesAsync(template.JobId, template.UnitId);
-                var linksText = string.Join("\n", relatedUnitNames.Select((name, i) => $"{i + 1}. {name}"));
-                resultName = Regex.Replace(resultName, "%СВЯЗИ-ПН%", linksText, RegexOptions.IgnoreCase);
-            }
+            // 6. Поля
+            var fieldShortcodes = GetShortCodes(result);
+            if (fieldShortcodes.Count > 0)
+                result = await ReplaceFieldValues(data.UnitId, result, fieldShortcodes).ConfigureAwait(false);
 
-            // 4. Поля (оставшиеся %FIELD_NAME%)
-            shortcodesInMask = GetShortCodes(resultName);
-            if (shortcodesInMask.Count > 0)
-                resultName = await ReplaceFieldValues(template.UnitId, resultName, shortcodesInMask);
-
-            logger.LogDebug("Подстановка завершена. Результат: '{Result}'", resultName);
-
-            return resultName;
+            return result;
         }
 
-        private bool IsAnyShortcodes(string str)
+        private async Task<string> GetUnitNameForTemplateAsync(Guid unitId)
         {
-            return Regex.IsMatch(str, shortcodePattern) ||
-                   Regex.IsMatch(str, maxShortcodePattern) ||
-                   Regex.IsMatch(str, lettersShortcodePattern);
+            var unit = await unitService.Get().AsNoTracking().FirstOrDefaultAsync(u => u.Id == unitId).ConfigureAwait(false);
+            if (unit == null || string.IsNullOrEmpty(unit.Name))
+                throw new InvalidOperationException($"Unit {unitId} не найден или не содержит Name.");
+            return unit.Name;
         }
 
         private static List<Match> GetShortCodes(string resultName)
         {
-            var shortcodesInMask = Regex.Matches(resultName, shortcodePattern).ToList();
+            var shortcodesInMask = GeneralShortcodeRegex.Matches(resultName).ToList();
             return shortcodesInMask;
         }
 
@@ -305,32 +512,48 @@ namespace PARR.DAL.DomainServices.Shortcodes
             {
                 new ShortcodeInfoDto { Shortcode = "%ЭК%",
                     Description = "Наименование ЭК(Код поиска)",
-                    Type = ShortcodeTypeEnum.Standart },
+                    Type = ShortcodeTypeEnum.Standard },
                 new ShortcodeInfoDto { Shortcode = "%ГРУППА_РАБОТ%",
                     Description = "Наименование группы работ",
-                    Type = ShortcodeTypeEnum.Standart },
+                    Type = ShortcodeTypeEnum.Standard },
                 new ShortcodeInfoDto { Shortcode = "%РАБОТА%",
                     Description = "Наименование работы в АСУ ЕСПП",
-                    Type = ShortcodeTypeEnum.Standart },
+                    Type = ShortcodeTypeEnum.Standard },
                 new ShortcodeInfoDto { Shortcode = "%ТНК%",
                     Description = "Полное наименование ТНК",
-                    Type = ShortcodeTypeEnum.Standart },
+                    Type = ShortcodeTypeEnum.Standard },
                 new ShortcodeInfoDto { Shortcode = "%ТНК-КРАТКО%",
                     Description = "Краткое наименование ТНК",
-                    Type = ShortcodeTypeEnum.Standart },
-                new ShortcodeInfoDto { Shortcode = "%ИНДЕКС%",
-                    Description = "Порядковый индекс шаблона для групповых работ",
-                    Type = ShortcodeTypeEnum.Standart },
-                new ShortcodeInfoDto { Shortcode = "%МАКС:ИМЯ АТРИБУТА%",
-                    Description = "Используется только с групповым типом работ. Наиболее часто встречающееся значение поля в группе (игнорирует пустые). Пример: %МАКС:РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК%",
-                    Type = ShortcodeTypeEnum.Standart },
-                new ShortcodeInfoDto{ Shortcode = "%БУКВЫ:ИМЯ АТРИБУТА%",
-                    Description = "Извлекает только буквы из значения поля. Пример: %БУКВЫ:ЗОНА_ОТВЕТСТВЕННОСТИ% → ПРИВ",
-                    Type = ShortcodeTypeEnum.Standart
+                    Type = ShortcodeTypeEnum.Standard },
+                new ShortcodeInfoDto { Shortcode = "%ТИКТАК%",
+                    Description = "Текущее время в формате Unix timestamp (секунды с 1970-01-01 UTC)",
+                    Type = ShortcodeTypeEnum.Standard
                 }
             });
 
-            // 3. Связи
+            // 3. Групповые шорткоды
+            result.AddRange(new[]
+            {
+                new ShortcodeInfoDto { Shortcode = "%ИНДЕКС%",
+                    Description = "Порядковый индекс шаблона для групповых работ",
+                    Type = ShortcodeTypeEnum.GroupValue },
+                new ShortcodeInfoDto { Shortcode = "%МАКС:ИМЯ АТРИБУТА%",
+                    Description = "Используется только с групповым типом работ. Наиболее часто встречающееся значение поля в группе (игнорирует пустые). Пример: %МАКС:РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК%",
+                    Type = ShortcodeTypeEnum.GroupValue },
+                new ShortcodeInfoDto { Shortcode = "%ГР_ПОЛЕ-ПН%",
+                    Description = "Нумерованный список unit-ов из шаблона: 1. ЭК-123 (Значение1, Значение2). Использует GroupingUnitFieldId из JobGroup.",
+                    Type = ShortcodeTypeEnum.GroupValue },
+            });
+
+            // 4. Трансформирующие шорткоды
+            result.Add(new ShortcodeInfoDto
+            {
+                Shortcode = "%БУКВЫ:ИМЯ АТРИБУТА%",
+                Description = "Извлекает только буквы из значения поля. Пример: %БУКВЫ:ЗОНА_ОТВЕТСТВЕННОСТИ% → ПРИВ",
+                Type = ShortcodeTypeEnum.Transform
+            });
+
+            // 5. Связи
             result.AddRange(new[]
             {
                 new ShortcodeInfoDto { Shortcode = "%СВЯЗИ%",
@@ -339,13 +562,10 @@ namespace PARR.DAL.DomainServices.Shortcodes
                 new ShortcodeInfoDto { Shortcode = "%СВЯЗИ-ПН%",
                     Description = "Связанные ЭК с нумерацией (1. ..., 2. ...), выбираются только при настроенном фильтре по полям в связанных ЭК",
                     Type = ShortcodeTypeEnum.Relationship },
-                new ShortcodeInfoDto { Shortcode = "%ГР_ПОЛЕ-ПН%",
-                    Description = "Нумерованный список unit-ов из шаблона: 1. ЭК-123 (Значение1, Значение2). Использует GroupingUnitFieldId из JobGroup.",
-                    Type = ShortcodeTypeEnum.Relationship },
             });
 
-            // 4. Все доступные поля из UnitField
-            var fieldNames = await unitFieldService.Get().AsNoTracking().Select(t => new { t.AihitName, t.DisplayName }).ToListAsync();
+            // 6. Все доступные поля из UnitField
+            var fieldNames = await unitFieldService.Get().AsNoTracking().Select(t => new { t.AihitName, t.DisplayName }).ToListAsync().ConfigureAwait(false);
             foreach (var fieldName in fieldNames.OrderBy(n => n.AihitName))
             {
                 result.Add(new ShortcodeInfoDto
@@ -367,7 +587,7 @@ namespace PARR.DAL.DomainServices.Shortcodes
             if (requiredFieldNames.Count == 0)
                 return resultName;
 
-            var fieldValues = await unitInValueService.GetFieldValuesAsync(unitId, requiredFieldNames);
+            var fieldValues = await unitInValueService.GetFieldValuesAsync(unitId, requiredFieldNames).ConfigureAwait(false);
 
             var fieldValuesMap = fieldValues
                 .GroupBy(x => x.FieldName, StringComparer.OrdinalIgnoreCase)
@@ -395,15 +615,56 @@ namespace PARR.DAL.DomainServices.Shortcodes
             return resultName;
         }
 
-        private static string ReplaceStandardShortcodes(JobForShortcodes job, Unit unit, string input, int? index = null)
+        private static string ReplaceStandardShortcodes(JobForShortcodes? job, string unitName, string input)
         {
-            return input
-                .Replace("%ЭК%", unit.Name, StringComparison.OrdinalIgnoreCase)
-                .Replace("%ГРУППА_РАБОТ%", job.Group?.GroupName ?? "", StringComparison.OrdinalIgnoreCase)
-                .Replace("%РАБОТА%", job.WorkName, StringComparison.OrdinalIgnoreCase)
-                .Replace("%ТНК%", job.Tnk?.Name ?? "", StringComparison.OrdinalIgnoreCase)
-                .Replace("%ТНК-КРАТКО%", job.Tnk?.ShortName ?? "", StringComparison.OrdinalIgnoreCase)
-                .Replace("%ИНДЕКС%", index?.ToString() ?? "", StringComparison.OrdinalIgnoreCase);
+            var result = input;
+
+            // %ЭК% — заменяем, только если есть в строке
+            if (result.Contains("%ЭК%", StringComparison.OrdinalIgnoreCase))
+            {
+                result = ReplaceSingleShortcode(result, "%ЭК%", unitName);
+            }
+
+            // %ТИКТАК% — не зависит от Job или Unit
+            if (result.Contains("%ТИКТАК%", StringComparison.OrdinalIgnoreCase))
+            {
+                result = ReplaceSingleShortcode(result, "%ТИКТАК%", DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString());
+            }
+
+            if (job != null)
+            {
+                if (result.Contains("%РАБОТА%", StringComparison.OrdinalIgnoreCase))
+                {
+                    result = ReplaceSingleShortcode(result, "%РАБОТА%", job.WorkName);
+                }
+
+                if (result.Contains("%ГРУППА_РАБОТ%", StringComparison.OrdinalIgnoreCase))
+                {
+                    result = ReplaceSingleShortcode(result, "%ГРУППА_РАБОТ%", job.Group?.GroupName);
+                }
+
+                if (result.Contains("%ТНК%", StringComparison.OrdinalIgnoreCase))
+                {
+                    result = ReplaceSingleShortcode(result, "%ТНК%", job.Tnk?.Name);
+                }
+
+                if (result.Contains("%ТНК-КРАТКО%", StringComparison.OrdinalIgnoreCase))
+                {
+                    result = ReplaceSingleShortcode(result, "%ТНК-КРАТКО%", job.Tnk?.ShortName);
+                }
+            }
+
+            return result;
+        }
+
+        private static string ReplaceSingleShortcode(string input, string shortcode, string? replacement)
+        {
+            if (replacement == null)
+            {
+                throw new InvalidOperationException($"Шорткод '{shortcode}' требует непустое значение, но подставляемое значение равно null.");
+            }
+
+            return input.Replace(shortcode, replacement, StringComparison.OrdinalIgnoreCase);
         }
 
         private static string ReplaceConstants(List<BLL.Domain.TemplateNameConstantPart> nameConstants, string resultName)
@@ -414,17 +675,17 @@ namespace PARR.DAL.DomainServices.Shortcodes
             return resultName;
         }
 
-        private async Task<string> ReplaceMaxShortcodesAsync(Guid jobGroupId, Guid unitId, string input, MatchCollection maxShortcodes)
+        private async Task<string> ReplaceMaxShortcodesAsync(Guid jobGroupId, Guid unitId, string input, MatchCollection maxShortcodes, string caller)
         {
             if (jobGroupId == Guid.Empty)
             {
-                logger.LogWarning("jobGroupId не задан. Пропускаем обработку %МАКС:...%");
+                logger.LogWarning("[{Caller}] jobGroupId не задан. Пропускаем обработку %МАКС:...%", caller);
                 return input;
             }
 
             if (unitId == Guid.Empty)
             {
-                logger.LogWarning("unitId не задан. Пропускаем обработку %МАКС:...%");
+                logger.LogWarning("[{Caller}] unitId не задан. Пропускаем обработку %МАКС:...%", caller);
                 return input;
             }
 
@@ -439,10 +700,10 @@ namespace PARR.DAL.DomainServices.Shortcodes
                 var matches = kvp.Value;
                 var fieldName = fullShortcode.Trim('%').Split(':', 2)[1].Trim();
 
-                logger.LogDebug("Обработка {Shortcode} для JobGroup {JobGroupId}, Template.UnitId {UnitId}, fieldName {FieldName}",
-                    fullShortcode, jobGroupId, unitId, fieldName);
+                logger.LogDebug("[{Caller}] Обработка {Shortcode} для JobGroup {JobGroupId}, Template.UnitId {UnitId}, fieldName {FieldName}",
+                    caller, fullShortcode, jobGroupId, unitId, fieldName);
 
-                var mostFrequentValue = await GetMaxShortCodeFromCacheOrDbAsync(jobGroupId, unitId, fullShortcode, fieldName);
+                var mostFrequentValue = await GetMaxShortCodeFromCacheOrDbAsync(jobGroupId, unitId, fullShortcode, fieldName, caller).ConfigureAwait(false);
 
                 foreach (var match in matches)
                     input = input.Replace(match.Value, mostFrequentValue);
@@ -451,30 +712,30 @@ namespace PARR.DAL.DomainServices.Shortcodes
             return input;
         }
 
-        private async Task<string> GetMaxShortCodeFromCacheOrDbAsync(Guid jobGroupId, Guid unitId, string fullShortcode, string fieldName)
+        private async Task<string> GetMaxShortCodeFromCacheOrDbAsync(Guid jobGroupId, Guid unitId, string fullShortcode, string fieldName, string caller)
         {
             if (jobGroupId == Guid.Empty)
             {
-                logger.LogWarning("jobGroupId не задан. Пропускаем обработку шорткода {Shortcode}", fullShortcode);
-                return "Нет данных";
+                logger.LogWarning("[{Caller}] jobGroupId не задан. Пропускаем обработку шорткода {Shortcode}", caller, fullShortcode);
+                return NoContent;
             }
 
             if (unitId == Guid.Empty)
             {
-                logger.LogWarning("unitId не задан. Пропускаем обработку шорткода {Shortcode}", fullShortcode);
-                return "Нет данных";
+                logger.LogWarning("[{Caller}] unitId не задан. Пропускаем обработку шорткода {Shortcode}", caller, fullShortcode);
+                return NoContent;
             }
 
             var cacheKey = $"gr_shcd_{jobGroupId:N}_{unitId:N}_{ComputeHash(fullShortcode)}";
 
-            var cachedData = await cacheService.GetCachedDataAsync<CachedGroupedShortCode>(cacheKey);
+            var cachedData = await cacheService.GetCachedDataAsync<CachedGroupedShortCode>(cacheKey).ConfigureAwait(false);
             if (cachedData != null)
             {
-                logger.LogDebug("Кэш попал для GroupedShortCode '{Name}': {Value}", fullShortcode, cachedData.Value);
+                logger.LogDebug("[{Caller}] Кэш попал для GroupedShortCode '{Name}': {Value}", caller, fullShortcode, cachedData.Value);
                 return cachedData.Value;
             }
 
-            logger.LogDebug("Кэш промахнут для GroupedShortCode '{Name}'. Запрашиваем из БД.", fullShortcode);
+            logger.LogDebug("[{Caller}] Кэш промахнут для GroupedShortCode '{Name}'. Запрашиваем из БД.", caller, fullShortcode);
 
             // Загружаем юниты из БД
             var effectiveUnitIds = await jobService.Get()
@@ -490,14 +751,14 @@ namespace PARR.DAL.DomainServices.Shortcodes
                 .SelectMany(template => template.UnitsInTemplate)
                 .Select(uit => uit.UnitId)
                 .Distinct()
-                .ToListAsync();
+                .ToListAsync().ConfigureAwait(false);
 
-            logger.LogDebug("EffectiveUnitIds: [{Ids}], Count: {Count}", string.Join(", ", effectiveUnitIds), effectiveUnitIds.Count);
+            logger.LogDebug("[{Caller}] EffectiveUnitIds: [{Ids}], Count: {Count}", caller, string.Join(", ", effectiveUnitIds), effectiveUnitIds.Count);
 
             // Вызываем метод из сервиса
-            var mostFrequentValue = await unitInValueService.GetMostFrequentValueForFieldAsync(effectiveUnitIds, fieldName);
+            var mostFrequentValue = await unitInValueService.GetMostFrequentValueForFieldAsync(effectiveUnitIds, fieldName).ConfigureAwait(false);
 
-            logger.LogDebug("Результат GetMostFrequentValueForFieldAsync: {Result}, для поля {FieldName}, unitIds: [{Ids}]", mostFrequentValue, fieldName, string.Join(", ", effectiveUnitIds));
+            logger.LogDebug("[{Caller}] Результат GetMostFrequentValueForFieldAsync: {Result}, для поля {FieldName}, unitIds: [{Ids}]", caller, mostFrequentValue, fieldName, string.Join(", ", effectiveUnitIds));
 
             // Не кэшируем пустые значения
             if (!string.IsNullOrEmpty(mostFrequentValue))
@@ -506,18 +767,18 @@ namespace PARR.DAL.DomainServices.Shortcodes
                 {
                     Value = mostFrequentValue,
                     Timestamp = DateTimeOffset.UtcNow,
-                    Source = GetType().Name,
+                    Source = typeof(ShortcodesService).Name,
                     Version = 1
                 };
 
-                await cacheService.SetCachedDataAsync(cacheKey, toCache, TimeSpan.FromHours(1));
+                await cacheService.SetCachedDataAsync(cacheKey, toCache, TimeSpan.FromHours(1)).ConfigureAwait(false);
                 return mostFrequentValue;
             }
 
-            return "Нет данных";
+            return NoContent;
         }
 
-        private async Task<string> ReplaceLettersShortcodesAsync(Guid unitId, string input, MatchCollection lettersShortcodes)
+        private async Task<string> ReplaceLettersShortcodesAsync(Guid unitId, string input, MatchCollection lettersShortcodes, string caller)
         {
             var shortcodeToMatches = lettersShortcodes
                 .Cast<Match>()
@@ -526,30 +787,29 @@ namespace PARR.DAL.DomainServices.Shortcodes
 
             foreach (var kvp in shortcodeToMatches)
             {
-                var fullShortcode = kvp.Key; // например, "%БУКВЫ:ЗОНА_ОТВЕТСТВЕННОСТИ%"
+                var fullShortcode = kvp.Key;
                 var matches = kvp.Value;
-                var fieldName = fullShortcode.Trim('%').Split(':', 2)[1].Trim(); // "ЗОНА_ОТВЕТСТВЕННОСТИ"
+                var fieldName = fullShortcode.Trim('%').Split(':', 2)[1].Trim();
 
-                logger.LogDebug("Обработка {Shortcode} для unitId {UnitId}, fieldName {FieldName}", fullShortcode, unitId, fieldName);
+                logger.LogDebug("[{Caller}] Обработка {Shortcode} для unitId {UnitId}, fieldName {FieldName}", caller, fullShortcode, unitId, fieldName);
 
-                //  Получаем значение поля через unitInValueService.GetFieldValuesAsync
-                var fieldValues = await unitInValueService.GetFieldValuesAsync(unitId, new List<string> { fieldName });
+                var fieldValues = await unitInValueService.GetFieldValuesAsync(unitId, new List<string> { fieldName }).ConfigureAwait(false);
 
                 string extractedLetters = string.Empty;
 
                 if (fieldValues.Any())
                 {
-                    var value = fieldValues.First().Value; // Берём первое значение, если несколько
+                    var value = fieldValues.First().Value;
                     if (value != null)
                     {
                         extractedLetters = ExtractLettersOnly(value);
-                        logger.LogDebug("Извлечены буквы: '{Letters}' из значения '{Value}'", extractedLetters, value);
+                        logger.LogDebug("[{Caller}] Извлечены буквы: '{Letters}' из значения '{Value}'", caller, extractedLetters, value);
                     }
                 }
 
                 if (string.IsNullOrEmpty(extractedLetters))
                 {
-                    logger.LogDebug("Для шорткода {Shortcode} не найдено подходящее значение или из него нельзя извлечь буквы", fullShortcode);
+                    logger.LogDebug("[{Caller}] Для шорткода {Shortcode} не найдено подходящее значение или из него нельзя извлечь буквы", caller, fullShortcode);
                 }
 
                 foreach (var match in matches)

PARR.DAL/ParrDalInstaller.cs

@@ -1,7 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using PARR.DAL.Cache.Services;
 using PARR.DAL.Cache.Services.Base;
 using PARR.DAL.Configurations.DbSettings;
 using PARR.DAL.Context;

PARR.DAL/Services/Implementations/TemplateService.cs

@@ -1,5 +1,7 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using Npgsql;
+using PARR.Common.Domain;
 using PARR.Constants;
 using PARR.DAL.Context;
 using PARR.DAL.Contracts;
@@ -46,7 +48,7 @@ namespace PARR.DAL.Services.Implementations
                     .ThenInclude(p => p!.Process)
                 .Include(t => t.Job)
                     .ThenInclude(t => t!.Group)
-                        .ThenInclude(t=>t.GroupType);
+                        .ThenInclude(t => t!.GroupType);
         }
 
         public override Task<bool> CreateAsync(Template obj)
@@ -82,5 +84,46 @@ namespace PARR.DAL.Services.Implementations
 
             return base.CreateAsync(obj);
         }
+
+
+        public async Task<Guid?> ReserveUnusedTemplateAsync(Guid newUnitId, HistoryInitiator initiator)
+        {
+            var sql = @"
+            UPDATE ""Templates"" 
+            SET ""StatusTypeId"" = @NewStatus,
+                ""DateModified"" = @DateModified,
+                ""InitiatorIp"" = @InitiatorIp,
+                ""InitiatorParrComponentId"" = @InitiatorComponent,
+                ""InitiatorComment"" = @InitiatorComment
+            WHERE ""Id"" = (
+                SELECT ""Id"" 
+                FROM ""Templates"" 
+                WHERE ""StatusTypeId"" = @OldStatus 
+                  AND ""UnitId"" != @NewUnitId
+                ORDER BY ""DateCreated"" ASC
+                LIMIT 1
+            )
+            RETURNING ""Id"";";
+
+            var parameters = new[]
+            {
+            new NpgsqlParameter("@NewStatus", (int)TemplateStatusTypeEnum.Updating),
+            new NpgsqlParameter("@DateModified", DateTimeOffset.UtcNow),
+            new NpgsqlParameter("@InitiatorIp", initiator.InitiatorIp ?? (object)DBNull.Value),
+            new NpgsqlParameter("@InitiatorComponent",
+                initiator.InitiatorParrComponentId.HasValue
+                    ? (object)(int)initiator.InitiatorParrComponentId.Value
+                    : DBNull.Value),
+            new NpgsqlParameter("@InitiatorComment", initiator.InitiatorComment ?? (object)DBNull.Value),
+            new NpgsqlParameter("@OldStatus", (int)TemplateStatusTypeEnum.Unused),
+            new NpgsqlParameter("@NewUnitId", newUnitId)
+        };
+
+            var result = await dataContext.Database
+                .SqlQueryRaw<Guid>(sql, parameters)
+                .ToListAsync();
+
+            return result.FirstOrDefault();
+        }
     }
 }

PARR.DAL/Services/Interfaces/ITemplateService.cs

@@ -1,4 +1,4 @@
-using PARR.DAL.Contracts;
+using PARR.Common.Domain;
 using PARR.DAL.Models;
 using PARR.DAL.Services.Interfaces.Base;
 
@@ -8,6 +8,8 @@ namespace PARR.DAL.Services.Interfaces
     {
         Task<Template?> GetTemplateByNameAsync(string name);
 
+        Task<Guid?> ReserveUnusedTemplateAsync(Guid newUnitId, HistoryInitiator initiator);
+
         IQueryable<Template> GetWithIncludes();
     }
 }

PARR.EsppSync/SyncService.cs

@@ -4,7 +4,6 @@ using Microsoft.Extensions.Logging;
 using PARR.Constants;
 using PARR.DAL.Contracts;
 using PARR.DAL.DomainServices.Shortcodes;
-using PARR.DAL.DomainServices.Shortcodes.Models;
 using PARR.DAL.Models;
 using PARR.DAL.Services.Interfaces;
 using System.Reflection;
@@ -90,51 +89,20 @@ namespace PARR.EsppSync
                         return;
                     }
 
-                    // Построим TemplateForShortcodes из уже загруженного template
-                    var templateForShortcodes = new TemplateForShortcodes
-                    {
-                        Id = template.Id,
-                        Index = template.Index,
-                        JobId = template.JobId,
-                        UnitId = template.UnitId,
-                        Job = template.Job == null ? null : new JobForShortcodes
-                        {
-                            Group = template.Job.Group == null ? null : new JobGroupForShortcodes
-                            {
-                                Id = template.Job.GroupId,
-                                GroupingUnitFieldId = template.Job.Group.GroupingUnitFieldId,
-                                GroupType = template.Job.Group.GroupType == null ? null : new JobGroupTypeForShortcodes
-                                {
-                                    Code = template.Job.Group.GroupType.Code
-                                },
-                                GroupName = template.Job.Group.GroupName
-                            },
-                            Tnk = template.Job.Tnk == null ? null : new TnkForShortcodes
-                            {
-                                Name = template.Job.Tnk.Name,
-                                ShortName = template.Job.Tnk.ShortName
-                            },
-                            WorkName = template.Job.WorkName,
-                            Name = template.Job.Name
-                        },
-                        UnitsInTemplate = template.UnitsInTemplate?.Select(uit => new UnitInTemplateForShortcodes { UnitId = uit.UnitId }).ToList() ?? new List<UnitInTemplateForShortcodes>()
-                    };
-
                     var dbObjectInEsppObject = converterToEsppObject.Invoke(template);
 
-                    //Проверяем наличие Shortcode в полях объекта из БД
+                    // Проверяем наличие Shortcode в полях объекта из БД
                     var properties = dbObjectInEsppObject.GetType().GetProperties();
 
                     foreach (PropertyInfo property in properties)
                     {
-                        var type = property.PropertyType;
-                        if(type == typeof(string)){
-                            // только для стрингов проверяем шорткоды
+                        if (property.PropertyType == typeof(string))
+                        {
                             var value = property.GetValue(dbObjectInEsppObject)?.ToString();
-
-                            if (value != null)
+                            if (!string.IsNullOrEmpty(value))
                             {
-                                var processedValue = await shortcodesService.ApplyShortcodesAsync(value, templateForShortcodes);
+                                // Передаём исходный template — он уже загружен с Include
+                                var processedValue = await shortcodesService.ApplyShortcodesAsync(value, template);
                                 property.SetValue(dbObjectInEsppObject, processedValue);
                             }
                         }

PARR.TemplateGeneratorWorker/TemplateGenerator.cs

@@ -66,6 +66,8 @@ namespace PARR.TemplateGeneratorWorker
             var job = await jobService
                             .Get().AsNoTracking()
                             .Include(t => t.Group)
+                            .ThenInclude(g => g!.GroupType)
+                            .Include(t => t.Tnk)
                             .FirstOrDefaultAsync(t => t.Id == query.JobId);
 
             if (job == null)
@@ -80,36 +82,20 @@ namespace PARR.TemplateGeneratorWorker
                 return;
             }
 
-            var templateForShortcodes = new TemplateForShortcodes
+            // === Создаём временный Template для подстановки шорткодов ===
+            var tempTemplateForShortcodes = new Template
             {
-                Id = Guid.Empty, // шаблон ещё не создан
-                Index = query.Index,
+                Id = Guid.Empty, // ещё не создан
+                Name = "", // не используется
                 JobId = query.JobId,
                 UnitId = query.UnitId,
-                Job = job == null ? null : new JobForShortcodes
-                {
-                    Group = job.Group == null ? null : new JobGroupForShortcodes
-                    {
-                        Id = job.GroupId,
-                        GroupingUnitFieldId = job.Group.GroupingUnitFieldId,
-                        GroupType = job.Group.GroupType == null ? null : new JobGroupTypeForShortcodes
-                        {
-                            Code = job.Group.GroupType.Code
-                        },
-                        GroupName = job.Group.GroupName
-                    },
-                    Tnk = job.Tnk == null ? null : new TnkForShortcodes
-                    {
-                        Name = job.Tnk.Name,
-                        ShortName = job.Tnk.ShortName
-                    },
-                    WorkName = job.WorkName,
-                    Name = job.Name
-                },
-                UnitsInTemplate = query.UnitsInTemplate?.Select(guid => new UnitInTemplateForShortcodes { UnitId = guid }).ToList() ?? new List<UnitInTemplateForShortcodes>()
+                Index = query.Index,
+                Job = job,
+                Unit = null, // ShortcodesService сам догрузит при необходимости
+                UnitsInTemplate = query.UnitsInTemplate?.Select(unitId => new UnitsInTemplate { UnitId = unitId }).ToList() ?? new List<UnitsInTemplate>()
             };
 
-            var templateName = await shortcodesService.ApplyShortcodesAsync(job!.TemplateNameMask!, templateForShortcodes);
+            var templateName = await shortcodesService.ApplyShortcodesAsync(job.TemplateNameMask!, tempTemplateForShortcodes);
 
             var nextRun = await esppScheduleTransformService.GetNextDateAsync(job.GroupId, job.Group!.ReferenceDate);
 
@@ -125,20 +111,10 @@ namespace PARR.TemplateGeneratorWorker
                 StatusTypeId = TemplateStatusTypeEnum.Used,
                 InitiatorComment = query.HistoryInitiator?.InitiatorComment,
                 InitiatorParrComponentId = query.HistoryInitiator?.InitiatorParrComponentId,
-                Index = query.Index 
+                Index = query.Index,
+                UnitsInTemplate = query.UnitsInTemplate?.Select(unitId => new UnitsInTemplate { UnitId = unitId }).ToList() ?? new List<UnitsInTemplate>()
             };
 
-            // Устанавливаем UnitsInTemplate
-            if (query.UnitsInTemplate != null && query.UnitsInTemplate.Any())
-            {
-                template.UnitsInTemplate = query.UnitsInTemplate.Select(unitId => new UnitsInTemplate { UnitId = unitId }).ToList();
-            }
-            else
-            {
-                // Если список пуст, все равно инициализируем коллекцию, чтобы избежать NullReferenceException при сохранении (если это не nullable)
-                template.UnitsInTemplate = new List<UnitsInTemplate>();
-            }
-
             if (await templateService.CreateAsync(template) && await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Запрос на генерацию с тестового шаблона", InitiatorParrComponentId = ParrComponentsEnum.TemplateTaskGenerator }))
             {
                 logger.LogInformation("Создан шаблон: Id={TemplateId}, Name={Name}, Job={JobId}, Unit={UnitId}, Index={Index}, UnitsInTemplateCount={UnitsCount}",

PARR.TemplateMatcher/Services/Implemetaions/GroupedTemplateSynchronizer.cs

@@ -21,7 +21,7 @@ namespace PARR.TemplateMatcher.Services.Implementations;
 internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 {
 #if DEBUG
-    private readonly Guid targetUnitId = Guid.Parse("d4322a08-246b-4380-8953-8ce4a8446235");
+    private readonly Guid targetUnitId = Guid.Parse("87fc4c36-1ea8-4163-983f-1605fee1de99");
 #endif
 
     private const bool DefaultUsedTemplateState = false;
@@ -163,7 +163,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         else
         {
             logger.LogDebug("Юнит {TargetUnitId} НЕ найден в expectedUnitIds.", targetUnitId);
-            //return; // ❌ юнит отсеялся на этом этапе
         }
 #endif
 
@@ -179,7 +178,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         // Загрузить UnitValues для юнитов из expectedUnitIds, чтобы проверить GroupingUnitFieldId
         var expectedUnitsWithGroupingField = await unitService.Get()
             .AsNoTracking()
-            .AsSplitQuery() // Для Unit -> UnitValues
             .Include(u => u.UnitValues)
                 .ThenInclude(uv => uv.Value)
             .Where(u => expectedUnitIds.Contains(u.Id))
@@ -199,7 +197,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         else
         {
             logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIdsWithValidGroupingFieldSet.", targetUnitId);
-            //return; // ❌ юнит отсеялся на этом этапе
         }
 #endif
 
@@ -212,15 +209,12 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         }
 
         // --- Дополнительная фильтрация по "РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК" ---
-        var unitIdsWithValidWorkGroupFieldSet = expectedUnitsWithGroupingField
-            .Where(u => unitIdsWithValidGroupingFieldSet.Contains(u.Id) && // Убедимся, что юнит уже прошёл фильтр по GroupingFieldId
-                        u.UnitValues.Any(uv =>
-                            uv.FieldId == workGroupFieldId && // Поле "РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК"
-                            uv.Value != null &&              // Значение существует
-                            regionalGroupValueIds.Contains(uv.Value.Id) // Значение в списке разрешённых
-                        ))
-            .Select(u => u.Id) // Выбираем Id юнита
-            .ToHashSet(); // И снова в HashSet
+        var unitIdsWithValidWorkGroupFieldSet = await FilterByWorkGroupFieldAsync(
+            expectedUnitsWithGroupingField,
+            unitIdsWithValidGroupingFieldSet,
+            workGroupFieldId,
+            regionalGroupValueIds
+        );
 
 #if DEBUG
         // Отладка: проверить, есть ли юнит в unitIdsWithValidWorkGroupFieldSet
@@ -231,7 +225,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         else
         {
             logger.LogDebug("Юнит {TargetUnitId} НЕ найден в unitIdsWithValidWorkGroupFieldSet.", targetUnitId);
-            //return; // ❌ юнит отсеялся на этом этапе
         }
 #endif
 
@@ -266,7 +259,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         else
         {
             logger.LogDebug("Юнит {TargetUnitId} НЕ участвует в потенциальных связях UnitInUnit.", targetUnitId);
-            // ❌ юнит отсеялся на этом этапе, если связи не требовались
         }
 #endif
 
@@ -343,7 +335,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         else
         {
             logger.LogDebug("Юнит {TargetUnitId} НЕ участвует в отфильтрованных связях UnitInUnit.", targetUnitId);
-            // ❌ юнит отсеялся на этом этапе, если связи требовались
         }
 #endif
 
@@ -386,7 +377,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         else
         {
             logger.LogDebug("Юнит {TargetUnitId} НЕ найден в groupedRelationships.Values до разрешения конфликтов.", targetUnitId);
-            // ❌ юнит отсеялся на этапе группировки
         }
 
         logger.LogDebug("Содержимое groupedRelationships до разрешения конфликтов: [{Groups}]", string.Join(", ", groupedRelationships.Select(kvp => $"Key: {kvp.Key}, Values: [{string.Join(", ", kvp.Value)}]")));
@@ -477,7 +467,6 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         else
         {
             logger.LogDebug("Юнит {TargetUnitId} НЕ найден в groupedRelationships.Values после разрешения конфликтов.", targetUnitId);
-            // юнит отсеялся на этапе разрешения конфликтов
         }
 #endif
 
@@ -504,11 +493,18 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
                 continue;
 
 #if DEBUG
-            // Отладка: проверить, есть ли ВРТ-AOS-05-ДВС в childUnitIds
-            var childUnitNamesForDebug = childUnitIds.Select(id => unitService.Get().AsNoTracking().Where(u => u.Id == id).Select(u => u.Name).FirstOrDefaultAsync().GetAwaiter().GetResult() ?? id.ToString()).ToList();
+            // === Безопасная асинхронная загрузка имён для отладки ===
+            var debugUnitIds = childUnitIds.Concat(new[] { relationshipUnitId }).Distinct().ToList();
+            var debugUnits = await unitService.Get()
+                .AsNoTracking()
+                .Where(u => debugUnitIds.Contains(u.Id))
+                .ToDictionaryAsync(u => u.Id, u => u.Name);
+
+            var childUnitNamesForDebug = childUnitIds.Select(id => debugUnits.GetValueOrDefault(id, id.ToString())).ToList();
+            var relationshipUnitName = debugUnits.GetValueOrDefault(relationshipUnitId, relationshipUnitId.ToString());
+
             if (childUnitNamesForDebug.Contains("ВРТ-AOS-05-ДВС"))
             {
-                var relationshipUnitName = await unitService.Get().AsNoTracking().Where(u => u.Id == relationshipUnitId).Select(u => u.Name).FirstOrDefaultAsync();
                 logger.LogDebug("Группа с ключом {Key} (название: {Name}) содержит юнит 'ВРТ-AOS-05-ДВС' в childUnitIds: [{ChildUnitNames}]", relationshipUnitId, relationshipUnitName, string.Join(", ", childUnitNamesForDebug));
             }
 #endif
@@ -553,6 +549,12 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 
                 // 9. Загрузить существующие шаблоны для targetJob, связанные с relationshipUnitId
                 var existingTemplatesForRelationship = await templateService.Get()
+                    .Include(t => t.Unit)
+                    .Include(t => t.Job)
+                        .ThenInclude(t => t!.Tnk)
+                    .Include(t => t.Job)
+                        .ThenInclude(t => t.Group)
+                            .ThenInclude(t => t.GroupType)
                     .AsNoTracking()
                     .Include(t => t.UnitsInTemplate)
                     .Where(t => t.JobId == targetJob.Id && t.UnitId == relationshipUnitId && t.Index == i && t.StatusTypeId == TemplateStatusTypeEnum.Used)
@@ -570,8 +572,8 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
                     {
                         logger.LogDebug("Шаблон {TemplateId} (Job {JobId}, Relationship {RelationshipId}, Index {Index}) актуален по юнитам.", existingTemplateForSubGroup.Id, targetJob.Id, relationshipUnitId, i);
 
-                        // Проверить, изменилось ли имя шаблона (например, из-за %МАКС:...% или %ТНК-КРАТКО%)
-                        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(targetJob, relationshipUnitId, i, subGroup);
+                        // Проверить, изменилось ли имя шаблона
+                        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(existingTemplateForSubGroup);
                         if (!string.Equals(existingTemplateForSubGroup.Name, expectedName, StringComparison.OrdinalIgnoreCase))
                         {
                             logger.LogDebug("Шаблон {TemplateId} требует обновления имени: старое = '{OldName}', новое = '{NewName}'", existingTemplateForSubGroup.Id, existingTemplateForSubGroup.Name, expectedName);
@@ -625,7 +627,20 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
                     {
                         logger.LogInformation("Переиспользован шаблон {TemplateId} для Job {JobId}, связанного юнита {RelationshipId}, Index {Index}.", reusableTemplate.Id, targetJob.Id, relationshipUnitId, i);
 
-                        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(targetJob, relationshipUnitId, i, subGroup);
+                        // === Создаём временный Template для нормализации имени ===
+                        var tempTemplateForName = new Template
+                        {
+                            Id = reusableTemplate.Id,
+                            Name = reusableTemplate.Name,
+                            JobId = targetJob.Id,
+                            UnitId = relationshipUnitId,
+                            Index = i,
+                            Job = targetJob,
+                            Unit = reusableTemplate.Unit,
+                            UnitsInTemplate = subGroup.Select(id => new UnitsInTemplate { UnitId = id }).ToList()
+                        };
+
+                        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(tempTemplateForName);
                         var nextRun = await GetNextRunAsync(targetJob);
 
                         var updateRequest = new TemplateUpdaterMq
@@ -719,13 +734,28 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 
     // --- Вспомогательные методы ---
 
+    /// <summary>
+    /// Фильтрует юниты по полю "РАБОЧАЯ_ГР_ОТВ_ЗА_ЭК"
+    /// </summary>
+    private async Task<HashSet<Guid>> FilterByWorkGroupFieldAsync(
+        List<Unit> units,
+        HashSet<Guid> candidateUnitIds,
+        Guid workGroupFieldId,
+        List<Guid> regionalGroupValueIds)
+    {
+        return units
+            .Where(u => candidateUnitIds.Contains(u.Id) &&
+                        u.UnitValues.Any(uv =>
+                            uv.FieldId == workGroupFieldId &&
+                            uv.Value != null &&
+                            regionalGroupValueIds.Contains(uv.Value.Id)))
+            .Select(u => u.Id)
+            .ToHashSet();
+    }
+
     /// <summary>
     /// Выбирает Job, соответствующий размеру подгруппы
     /// </summary>
-    /// <param name="jobsInGroup">Список Job'ов в группе</param>
-    /// <param name="subGroupSize">Размер подгруппы</param>
-    /// <param name="maxJob">Job с максимальным MaxValueRelationships</param>
-    /// <returns>Найденный Job или maxJob, если не найден подходящий</returns>
     private Job SelectTargetJob(List<Job> jobsInGroup, int subGroupSize, Job maxJob)
     {
         Job? targetJob = jobsInGroup
@@ -742,7 +772,7 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
 
         if (targetJob == null)
         {
-            targetJob = maxJob; // maxJob уже проверен на null ранее
+            targetJob = maxJob;
             logger.LogDebug("Для подгруппы размером {Size} не найден подходящий Job, используем maxJob {MaxJobId}.", subGroupSize, maxJob.Id);
         }
         else
@@ -764,7 +794,20 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
             return;
         }
 
-        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(targetJob, template.UnitId, template.Index, newUnitIds);
+        // === Создаём временный Template для нормализации имени ===
+        var tempTemplateForName = new Template
+        {
+            Id = template.Id,
+            Name = template.Name,
+            JobId = targetJob.Id,
+            UnitId = template.UnitId,
+            Index = template.Index,
+            Job = targetJob,
+            Unit = template.Unit,
+            UnitsInTemplate = newUnitIds.Select(id => new UnitsInTemplate { UnitId = id }).ToList()
+        };
+
+        var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(tempTemplateForName);
         var nextRun = await GetNextRunAsync(targetJob, template.NextRun);
 
         var updateRequest = new TemplateUpdaterMq
@@ -793,9 +836,9 @@ internal class GroupedTemplateSynchronizer : ITemplateSynchronizer
         var mqRequest = new TemplateGeneratorMq
         {
             JobId = jobId,
-            UnitId = relationshipUnitId, // UnitId шаблона
-            UnitsInTemplate = unitIds, // Юниты для UnitsInTemplate
-            Index = index, // Индекс шаблона
+            UnitId = relationshipUnitId,
+            UnitsInTemplate = unitIds,
+            Index = index,
             HistoryInitiator = initiator
         };
 

PARR.TemplateMatcher/Services/Implemetaions/SimpleTemplateSynchronizer.cs

@@ -6,6 +6,7 @@ using PARR.Common.Domain;
 using PARR.Constants;
 using PARR.DAL.DomainServices.Interfaces;
 using PARR.DAL.DomainServices.Shortcodes;
+using PARR.DAL.Models;
 using PARR.DAL.Models.Job;
 using PARR.DAL.Services.Interfaces;
 using PARR.DAL.Services.Interfaces.Job;
@@ -127,6 +128,12 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
 
         var existingTemplates = await templateService.Get()
             .Include(t => t.UnitsInTemplate)
+            .Include(t => t.Job)
+                .ThenInclude(t => t!.Group)
+                    .ThenInclude(t => t.GroupType)
+            .Include(t => t.Job)
+                .ThenInclude(t => t!.Tnk)
+            .Include(t => t.Unit)
             .Where(t => t.JobId == jobId)
             .ToListAsync();
 
@@ -147,12 +154,24 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
         foreach (var unitId in newUnitIds)
         {
             var reusableTemplate = await templateReuser.TryReuseOneUnusedTemplateAsync(jobId, unitId, initiator);
-
             if (reusableTemplate != null)
             {
                 logger.LogInformation("Переиспользован шаблон {TemplateId} для Job {JobId}, UnitId {UnitId}.", reusableTemplate.Id, jobId, unitId);
 
-                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(job, unitId);
+                // === Создаём временный Template для нормализации имени ===
+                var tempTemplateForName = new Template
+                {
+                    Id = reusableTemplate.Id,
+                    Name = reusableTemplate.Name,
+                    JobId = jobId,
+                    UnitId = unitId,
+                    Index = reusableTemplate.Index,
+                    Job = job, // загруженный job
+                    Unit = reusableTemplate.Unit, // может быть null — нормально
+                    UnitsInTemplate = new List<UnitsInTemplate>() // для простого шаблона
+                };
+
+                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(tempTemplateForName);
                 var nextRun = await GetNextRunAsync(job);
 
                 var updateRequest = new TemplateUpdaterMq
@@ -183,7 +202,7 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
         {
             if (unitIds.Contains(template.UnitId))
             {
-                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(job, template.UnitId);
+                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(template);
                 if (!string.Equals(template.Name, expectedName, StringComparison.OrdinalIgnoreCase))
                 {
                     logger.LogDebug("Шаблон {TemplateId} требует обновления имени: старое = '{OldName}', новое = '{NewName}'", template.Id, template.Name, expectedName);
@@ -267,7 +286,13 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
 
         var existingTemplates = await templateService.Get()
             .AsNoTracking()
+            .Include(t => t.Unit)
             .Include(t => t.UnitsInTemplate)
+            .Include(t => t.Job)
+                .ThenInclude(t => t!.Group)
+                    .ThenInclude(t => t!.GroupType)
+            .Include(t => t.Job)
+                .ThenInclude(t => t!.Tnk)
             .Where(t => t.JobId == jobId && t.StatusTypeId == TemplateStatusTypeEnum.Used)
             .ToListAsync();
 
@@ -275,7 +300,7 @@ internal class SimpleTemplateSynchronizer : ITemplateSynchronizer
         {
             if (unitIds.Contains(template.UnitId))
             {
-                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(job, template.UnitId);
+                var expectedName = await templateNameNormalizer.GetNormalizedTemplateNameAsync(template);
                 if (!string.Equals(template.Name, expectedName, StringComparison.OrdinalIgnoreCase))
                 {
                     logger.LogDebug("Шаблон {TemplateId} требует обновления имени: старое = '{OldName}', новое = '{NewName}'", template.Id, template.Name, expectedName);

PARR.TemplateMatcher/Services/Implemetaions/TemplateDeactivator.cs

@@ -76,8 +76,20 @@ internal class TemplateDeactivator : ITemplateDeactivator
             return false;
         }
 
-        // Вычисляем имя шаблона с новым Job
-        var expectedName = await namenormalizer.GetNormalizedTemplateNameAsync(unusedJob, template.UnitId);
+        // === Создаём временный Template для нормализации имени ===
+        var tempTemplateForName = new Template
+        {
+            Id = template.Id,
+            Name = template.Name,
+            JobId = unusedJob.Id,
+            UnitId = template.UnitId,
+            Index = template.Index,
+            Job = unusedJob,
+            Unit = template.Unit,
+            UnitsInTemplate = new List<UnitsInTemplate>()
+        };
+
+        var expectedName = await namenormalizer.GetNormalizedTemplateNameAsync(tempTemplateForName);
 
         var updateRequest = new TemplateUpdaterMq
         {

PARR.TemplateMatcher/Services/Implemetaions/TemplateNameNormalizer.cs

@@ -1,7 +1,7 @@
 using PARR.DAL.DomainServices.Shortcodes;
-using PARR.DAL.DomainServices.Shortcodes.Models;
-using PARR.DAL.Models.Job;
+using PARR.DAL.Models;
 using PARR.TemplateMatcher.Services.Interfaces;
+using System.Runtime.CompilerServices;
 
 namespace PARR.TemplateMatcher.Services.Implementations;
 
@@ -14,38 +14,15 @@ internal class TemplateNameNormalizer : ITemplateNameNormalizer
         this.shortcodesService = shortcodesService;
     }
 
-    public async Task<string> GetNormalizedTemplateNameAsync(Job job, Guid unitId, int? index = null, List<Guid>? templateUnitIds = null)
+    public async Task<string> GetNormalizedTemplateNameAsync(Template template, [CallerMemberName] string? caller = null)
     {
-        var templateForShortcodes = new TemplateForShortcodes
-        {
-            Id = Guid.Empty,
-            Index = (index != null) ? index + 1 : index,
-            JobId = job.Id,
-            UnitId = unitId,
-            Job = new JobForShortcodes
-            {
-                Group = job.Group != null ? new JobGroupForShortcodes
-                {
-                    Id = job.Group.Id,
-                    GroupingUnitFieldId = job.Group.GroupingUnitFieldId,
-                    GroupType = job.Group.GroupType != null ? new JobGroupTypeForShortcodes
-                    {
-                        Code = job.Group.GroupType.Code
-                    } : null,
-                    GroupName = job.Group.GroupName
-                } : null,
-                Tnk = job.Tnk != null ? new TnkForShortcodes
-                {
-                    Name = job.Tnk.Name,
-                    ShortName = job.Tnk.ShortName ?? ""
-                } : null,
-                WorkName = job.WorkName,
-                Name = job.Name
-            },
-            UnitsInTemplate = templateUnitIds?.Select(id => new UnitInTemplateForShortcodes { UnitId = id }).ToList() ?? new List<UnitInTemplateForShortcodes>()
-        };
+        var callerName = caller ?? "Unknown";
+
+        if (template.Job == null)
+            throw new ArgumentNullException(nameof(template.Job));
+
+        var rawName = await shortcodesService.ApplyShortcodesAsync(template.Job.TemplateNameMask, template, callerName);
 
-        var rawName = await shortcodesService.ApplyShortcodesAsync(job.TemplateNameMask, templateForShortcodes);
         return rawName.ToUpper();
     }
 }

PARR.TemplateMatcher/Services/Implemetaions/TemplateReuser.cs

@@ -1,7 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using PARR.Common.Domain;
-using PARR.Constants;
 using PARR.DAL.Models;
 using PARR.DAL.Services.Interfaces;
 using PARR.TemplateMatcher.Services.Interfaces;
@@ -10,8 +9,6 @@ namespace PARR.TemplateMatcher.Services.Implementations;
 
 internal class TemplateReuser : ITemplateReuser
 {
-    private const int UnusedCandidateBatchSize = 10;
-
     private readonly ILogger<TemplateReuser> logger;
     private readonly ITemplateService templateService;
 
@@ -25,7 +22,7 @@ internal class TemplateReuser : ITemplateReuser
 
     public async Task<Template?> TryReuseOneUnusedTemplateAsync(
         Guid jobId,
-        Guid unitId, 
+        Guid unitId,
         HistoryInitiator initiator,
         int maxAttempts = 3)
     {
@@ -33,57 +30,47 @@ internal class TemplateReuser : ITemplateReuser
         {
             try
             {
-                var unusedCandidates = await templateService.Get()
-                    .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Unused)
-                    .OrderBy(t => t.DateModified ?? t.DateCreated)
-                    .Take(UnusedCandidateBatchSize)
-                    .ToListAsync();
+                // Атомарно резервируем один шаблон через DAL
+                var templateId = await templateService.ReserveUnusedTemplateAsync(unitId, initiator);
 
-                if (!unusedCandidates.Any())
+                if (templateId == null)
                 {
-                    logger.LogDebug("Нет Unused-шаблонов (попытка {Attempt}).", attempt);
+                    logger.LogDebug("Нет доступных Unused-шаблонов для переиспользования (попытка {Attempt}).", attempt);
                     return null;
                 }
 
-                foreach (var candidate in unusedCandidates)
+                // Загружаем зарезервированный шаблон
+                var template = await templateService.Get()
+                    .AsNoTracking()
+                    .Include(t=>t.Unit)
+                    .Include(t=>t.Job)
+                        .ThenInclude(t=>t!.Tnk)
+                    .Include(t => t.Job)
+                        .ThenInclude(t => t!.Group)
+                            .ThenInclude(t=>t!.GroupType)
+                    .FirstOrDefaultAsync(t => t.Id == templateId);
+
+                if (template == null)
                 {
-                    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;
-                    }
+                    logger.LogWarning("Зарезервированный шаблон {TemplateId} не найден при загрузке.", templateId);
+                    continue; 
                 }
 
-                if (attempt < maxAttempts)
-                    await Task.Delay(Random.Shared.Next(5, 15) * attempt);
+                logger.LogInformation(
+                    "Успешно захвачен шаблон {TemplateId} (старый Job {OldJobId}) для нового Job {NewJobId}, Unit {UnitId} (попытка {Attempt}).",
+                    template.Id, template.JobId, jobId, unitId, attempt);
+
+                return template;
             }
             catch (Exception ex)
             {
-                logger.LogError(ex, "Ошибка в попытке захвата (попытка {Attempt}).", attempt);
-                if (attempt == maxAttempts) throw;
+                logger.LogError(ex, "Ошибка при попытке захвата шаблона (попытка {Attempt}).", attempt);
+
+                if (attempt == maxAttempts)
+                    throw; 
+
+                // Небольшая задержка перед повтором
+                await Task.Delay(Random.Shared.Next(10, 50));
             }
         }
 

PARR.TemplateMatcher/Services/Interfaces/ITemplateNameNormalizer.cs

@@ -1,9 +1,10 @@
-using PARR.DAL.Models.Job;
+using PARR.DAL.Models;
+using System.Runtime.CompilerServices;
 
 namespace PARR.TemplateMatcher.Services.Interfaces
 {
     public interface ITemplateNameNormalizer
     {
-        Task<string> GetNormalizedTemplateNameAsync(Job job, Guid unitId, int? index = null, List<Guid>? templateUnitIds = null);
+        Task<string> GetNormalizedTemplateNameAsync(Template template, [CallerMemberName] string? caller = null);
     }
 }