diff --git a/PARR.API/Contracts/V1/Responses/Statistics/StatTemplateDistributorResponse.cs b/PARR.API/Contracts/V1/Responses/Statistics/StatTemplateDistributorResponse.cs
index d1e87774..7a090e07 100644
--- a/PARR.API/Contracts/V1/Responses/Statistics/StatTemplateDistributorResponse.cs
+++ b/PARR.API/Contracts/V1/Responses/Statistics/StatTemplateDistributorResponse.cs
@@ -56,5 +56,6 @@
         public DateTimeOffset NextRun { get; set; }
         public bool IsActiveTemplate { get; set; }
         public bool IsActiveSchedular { get; set; }
+        public required ScheduleResponseAreaTimeOffsetResponse ResponseAreaOffset { get; set; }
     }
 }
diff --git a/PARR.API/Contracts/V1/Responses/TemplateResponse.cs b/PARR.API/Contracts/V1/Responses/TemplateResponse.cs
index f210efc2..f7810309 100644
--- a/PARR.API/Contracts/V1/Responses/TemplateResponse.cs
+++ b/PARR.API/Contracts/V1/Responses/TemplateResponse.cs
@@ -16,10 +16,10 @@
 
         public DateTimeOffset NextRun { get; set; }
 
-        /// <summary>
-        /// NextRun с учетом ЗО (локальное время по ЗО, не UTC)
-        /// </summary>
-        public DateTimeOffset? NextRunResponseAreaInLocal { get; set; }
+        ///// <summary>
+        ///// NextRun с учетом ЗО (локальное время по ЗО, не UTC)
+        ///// </summary>
+        //public DateTimeOffset? NextRunResponseAreaInLocal { get; set; }
 
         public bool IsResponseAreaTimezone { get; set; }
 
@@ -45,7 +45,7 @@
 
         public bool IsAutoDistributionEnabled { get; set; }
 
-        public ScheduleResponseAreaTimeOffsetResponse? Timezone { get; set; }
+        public ScheduleResponseAreaTimeOffsetResponse? ResponseAreaOffset { get; set; }
     }
 
 
diff --git a/PARR.API/Controllers/V1/ResponseAreaController.cs b/PARR.API/Controllers/V1/ResponseAreaController.cs
index 5d9741bc..163457ea 100644
--- a/PARR.API/Controllers/V1/ResponseAreaController.cs
+++ b/PARR.API/Controllers/V1/ResponseAreaController.cs
@@ -3,12 +3,10 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
 using PARR.API.Contracts.V1;
-using PARR.API.Contracts.V1.Requests.Queries;
 using PARR.API.Contracts.V1.Responses;
 using PARR.API.Contracts.V1.Responses.Base;
 using PARR.API.Controllers.V1.Base;
 using PARR.Constants;
-using PARR.DAL.DomainModels;
 using PARR.DAL.Services.Interfaces;
 
 namespace PARR.API.Controllers.V1
diff --git a/PARR.API/Controllers/V1/Statistics/StatTemplateDistributionController.cs b/PARR.API/Controllers/V1/Statistics/StatTemplateDistributionController.cs
index d5a224d5..862a196f 100644
--- a/PARR.API/Controllers/V1/Statistics/StatTemplateDistributionController.cs
+++ b/PARR.API/Controllers/V1/Statistics/StatTemplateDistributionController.cs
@@ -15,6 +15,7 @@ using PARR.DAL.Models.Job;
 using PARR.DAL.NextRunServices;
 using PARR.DAL.Services.Interfaces;
 using PARR.DAL.Services.Interfaces.Job;
+using PARR.DAL.Services.Interfaces.Schedule;
 
 namespace PARR.API.Controllers.V1.Statistics
 {
@@ -30,6 +31,7 @@ namespace PARR.API.Controllers.V1.Statistics
         private readonly IShortcodesService shortcodesService;
         private readonly INextRunService nextRunService;
         private readonly ILogger<StatTemplateDistributionController> logger;
+        private readonly IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService;
 
         public StatTemplateDistributionController(
             ITemplateService templateService,
@@ -37,7 +39,8 @@ namespace PARR.API.Controllers.V1.Statistics
             IMapper mapper,
             IShortcodesService shortcodesService,
             INextRunService nextRunService,
-            ILogger<StatTemplateDistributionController> logger
+            ILogger<StatTemplateDistributionController> logger,
+            IScheduleResponseAreaTimeOffsetService scheduleResponseAreaTimeOffsetService
             )
         {
             this.templateService = templateService;
@@ -46,6 +49,7 @@ namespace PARR.API.Controllers.V1.Statistics
             this.shortcodesService = shortcodesService;
             this.nextRunService = nextRunService;
             this.logger = logger;
+            this.scheduleResponseAreaTimeOffsetService = scheduleResponseAreaTimeOffsetService;
         }
 
 
@@ -77,7 +81,8 @@ namespace PARR.API.Controllers.V1.Statistics
                                     .Where(t => t.Job!.GroupId == jobGroupId && t.StatusTypeId == TemplateStatusTypeEnum.Used)
                                     .Select(t => new
                                     {
-                                        WorkGroup = t.Job!.WorkGroupMask,
+                                        WorkGroupMask = t.Job!.WorkGroupMask,
+                                        ResponseAreaMask = t.Job!.ResponseAreaMask,
                                         Template = t
                                     })
                                     .AsNoTracking()
@@ -108,23 +113,24 @@ namespace PARR.API.Controllers.V1.Statistics
                 // тут группируем по рабочим группам
 
                 // Получаем список пар (WorkGroupName, Template)
-                var templatesWithWorkGroupNames = new List<(string WorkGroupName, Template Template)>();
+                var templatesWithWorkGroupNames = new List<(string WorkGroupName, (Template Template, string ResponseArea))>();
 
-                // получаем названия рабочих групп
+                // получаем названия рабочих групп и ЗО
                 foreach (var item in items)
                 {
-                    var workGroupName = await shortcodesService.ApplyShortcodesAsync(item.WorkGroup, item.Template);
-                    templatesWithWorkGroupNames.Add((workGroupName, item.Template));
+                    var workGroupName = await shortcodesService.ApplyShortcodesAsync(item.WorkGroupMask, item.Template);
+                    var responseArea = await shortcodesService.ApplyShortcodesAsync(item.ResponseAreaMask, item.Template);
+                    templatesWithWorkGroupNames.Add((workGroupName, (item.Template, responseArea)));
                 }
 
                 // Группируем по WorkGroupName
                 var grouped = templatesWithWorkGroupNames
                                     .GroupBy(x => x.WorkGroupName)
-                                    .ToDictionary(g => g.Key, g => g.Select(x => x.Template).ToList());
+                                    .ToDictionary(g => g.Key, g => g.Select(x => x.Item2).ToList());
 
                 foreach (var groupedItem in grouped)
                 {
-                    var statResult = GetResponseByWorkGroup(groupedItem.Key, groupedItem.Value, workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate);
+                    var statResult = GetResponseByWorkGroup(groupedItem.Key, groupedItem.Value.ToList(), workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate);
                     responseItemsList.Add(statResult);
                 }
             }
@@ -132,8 +138,16 @@ namespace PARR.API.Controllers.V1.Statistics
             {
                 // не нужно группировать по рабочим группам
 
+                // получаем названия ЗО
+                var templatesWithResponseArea = new List<(Template Template, string ResponseArea)>();
+                foreach (var item in items)
+                {
+                    var responseArea = await shortcodesService.ApplyShortcodesAsync(item.ResponseAreaMask, item.Template);
+                    templatesWithResponseArea.Add((item.Template, responseArea));
+                }
+
                 // сразу формируем response
-                responseItemsList.Add(GetResponseByWorkGroup(null, items.Select(t => t.Template).ToList(), workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate));
+                responseItemsList.Add(GetResponseByWorkGroup(null, templatesWithResponseArea, workDays, weekends, timeZoneQuery.TimeZoneOffsetHours, jobGroup.ReferenceDate));
             }
 
             var response = new StatTemplateDistributorResponse
@@ -180,11 +194,11 @@ namespace PARR.API.Controllers.V1.Statistics
         /// Заполнить респонс
         /// </summary>
         /// <param name="workGroupName"></param>
-        /// <param name="templates"></param>
+        /// <param name="templateList"></param>
         /// <param name="workDays"></param>
         /// <param name="timeZoneOffsetHours"></param>
         /// <returns></returns>
-        private StatDistributorItemResponse GetResponseByWorkGroup(string? workGroupName, List<Template> templates, List<DateOnly> workDays, HashSet<DateOnly> weekends, int timeZoneOffsetHours, DateTimeOffset referenceDate)
+        private StatDistributorItemResponse GetResponseByWorkGroup(string? workGroupName, List<(Template Template, string ResponseArea)> templateList, List<DateOnly> workDays, HashSet<DateOnly> weekends, int timeZoneOffsetHours, DateTimeOffset referenceDate)
         {
             var result = new StatDistributorItemResponse
             {
@@ -202,7 +216,8 @@ namespace PARR.API.Controllers.V1.Statistics
 
             //foreach (var templatesFromDate in templates.GroupBy(t => DateOnly.FromDateTime(t.NextRun.Date)))
             // смещаем по часовой зоне и группируем по дате
-            foreach (var templatesFromDate in templates.GroupBy(t => DateOnly.FromDateTime(t.NextRun.AddHours(timeZoneOffsetHours).Date)))
+            //foreach (var templatesFromDate in templates.GroupBy(t => DateOnly.FromDateTime(t.NextRun.AddHours(timeZoneOffsetHours).Date)))
+            foreach (var templatesFromDate in templateList.GroupBy(t => DateOnly.FromDateTime(t.Template.NextRun.AddHours(timeZoneOffsetHours).Date)))
             {
                 var statisticsForDate = result.Statistics.FirstOrDefault(t => DateOnly.FromDateTime(t.Date.AddHours(timeZoneOffsetHours).Date) == templatesFromDate.Key);
                 if (statisticsForDate == null)
@@ -212,14 +227,15 @@ namespace PARR.API.Controllers.V1.Statistics
                 }
 
                 statisticsForDate.AllCount = templatesFromDate.Count();
-                statisticsForDate.IsDeactivatedCount = templatesFromDate.Count(t => !t.IsActiveTemplate || !t.IsActiveSchedule);
-                statisticsForDate.IsActivatedCount = templatesFromDate.Count(t => t.IsActiveTemplate && t.IsActiveSchedule);
+                statisticsForDate.IsDeactivatedCount = templatesFromDate.Count(t => !t.Template.IsActiveTemplate || !t.Template.IsActiveSchedule);
+                statisticsForDate.IsActivatedCount = templatesFromDate.Count(t => t.Template.IsActiveTemplate && t.Template.IsActiveSchedule);
                 statisticsForDate.Templates = templatesFromDate.Select(t => new StatTempleteDistribItem
                 {
-                    Name = t.Name,
-                    IsActiveSchedular = t.IsActiveSchedule,
-                    IsActiveTemplate = t.IsActiveTemplate,
-                    NextRun = t.NextRun
+                    Name = t.Template.Name,
+                    IsActiveSchedular = t.Template.IsActiveSchedule,
+                    IsActiveTemplate = t.Template.IsActiveTemplate,
+                    NextRun = t.Template.NextRun,
+                    ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(t.ResponseArea))
                 })
                 .OrderBy(t => t.Name)
                 .ToList();
diff --git a/PARR.API/Controllers/V1/TemplateController.cs b/PARR.API/Controllers/V1/TemplateController.cs
index 51f0ee71..af348e92 100644
--- a/PARR.API/Controllers/V1/TemplateController.cs
+++ b/PARR.API/Controllers/V1/TemplateController.cs
@@ -76,21 +76,6 @@ namespace PARR.API.Controllers.V1
         {
             var paginationFilter = mapper.Map<PaginationFilter>(paginationQuery);
 
-            //IQueryable<Template> query = templateService.GetWithIncludes().AsNoTracking()
-            //                                                 .Include(t => t.Unit).ThenInclude(t => t!.UnitValues).ThenInclude(t => t.Field)
-            //                                                 .Include(t => t.Unit).ThenInclude(t => t!.UnitValues).ThenInclude(t => t.Value)
-            //                                                 .Include(t => t.RobotConfigurations).ThenInclude(t => t.Robot)
-            //                                                 .Include(t => t.RobotConfigurations).ThenInclude(t => t.TaskStatus)
-            //                                                 .Include(t => t.RobotConfigurations).ThenInclude(t => t.RobotStatus)
-            //                                                 .Include(t => t.Orders)
-            //                                                 .Include(t => t.StatusType)
-            //                                                 .Include(t => t.Job).ThenInclude(t => t.Group).ThenInclude(t => t.ScheduleExcludeType)
-            //                                                 .Include(t => t.Job).ThenInclude(t => t.Group).ThenInclude(t => t.ScheduleExcludeTypeCalendar)
-            //                                                 .OrderBy(t => t.Name)
-            //                                                 .AsSplitQuery();
-
-            //var sw = Stopwatch.StartNew();
-
             IQueryable<Template> query = templateService.Get()
                                             .Include(t => t.Unit).ThenInclude(t => t!.UnitValues).ThenInclude(t => t.Field)
                                             .Include(t => t.Unit).ThenInclude(t => t!.UnitValues).ThenInclude(t => t.Value)
@@ -153,7 +138,7 @@ namespace PARR.API.Controllers.V1
                 {
                     //await ApplyTemplateShortcodesAsync(responseItem, templates.First(t => t.Id == responseItem.Id));
                     await ApplyTemplateShortcodesAsync(responseItem, templatesDict[responseItem.Id]);
-                    FillNextRunWithResponseAreaInLocal(responseItem);
+                    FillResponseAreaOffset(responseItem);
                 }
                 //logger.LogDebug("Получение шорткодов: {ElapsedMs} мс", sw.ElapsedMilliseconds);
                 //sw.Stop();
@@ -198,7 +183,7 @@ namespace PARR.API.Controllers.V1
 
             var response = mapper.Map<TemplateResponse>(template);
             await ApplyTemplateShortcodesAsync(response, template);
-            FillNextRunWithResponseAreaInLocal(response);
+            FillResponseAreaOffset(response);
 
             var ordersCountResult = await GetOrdersCountAsync(new List<Guid> { response.Id });
             response.OrderCount = ordersCountResult.Count > 0 ? ordersCountResult.First().Value : 0;
@@ -292,7 +277,7 @@ namespace PARR.API.Controllers.V1
             var response = mapper.Map<TemplateListResponse>(templateToResponse);
 
             await ApplyTemplateShortcodesAsync(response, templateToResponse);
-            FillNextRunWithResponseAreaInLocal(response);
+            FillResponseAreaOffset(response);
 
             var ordersCountResult = await GetOrdersCountAsync(new List<Guid> { response.Id });
             response.OrderCount = ordersCountResult.Count > 0 ? ordersCountResult.First().Value : 0;
@@ -339,23 +324,34 @@ namespace PARR.API.Controllers.V1
 
 
         /// <summary>
-        /// Заполнить NextRunResponseAreaInLocal
+        /// Заполнить ResponseAreaOffset
         /// </summary>
         /// <param name="response"></param>
-        private void FillNextRunWithResponseAreaInLocal(TemplateBaseResponse response)
+        private void FillResponseAreaOffset(TemplateBaseResponse response)
         {
-            var responseArea = response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea)
-                                            ? response.ResponseArea
-                                            : settingsFromDb.DefaultResponseAreaToTimeOffset;
+            // если стоит галка IsResponseAreaTimezone и есть ЗО, то возвращаем оффсет
+            if (response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea))
+            {
+                var responseArea = response.ResponseArea;
+                response.ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea));
+            }
+            else
+            {
+                response.ResponseAreaOffset = null;
+            }
+
+            //var responseArea = response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea)
+            //                                ? response.ResponseArea
+            //                                : settingsFromDb.DefaultResponseAreaToTimeOffset;
 
             //response.NextRunResponseAreaInLocal = response.IsResponseAreaTimezone && !string.IsNullOrEmpty(response.ResponseArea)
             //                                            ? nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, response.ResponseArea)
             //                                            // возвращаем в дефолтной зоне
             //                                            : nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, settingsFromDb.DefaultResponseAreaToTimeOffset);
 
-            response.NextRunResponseAreaInLocal = nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, responseArea);
+            //response.NextRunResponseAreaInLocal = nextRunService.GetNextRunWithResponseAreaOffset(response.NextRun, responseArea);
 
-            response.Timezone = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea));
+            //response.ResponseAreaOffset = mapper.Map<ScheduleResponseAreaTimeOffsetResponse>(scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea));
         }
 
     }
diff --git a/PARR.DAL/NextRunServices/INextRunService.cs b/PARR.DAL/NextRunServices/INextRunService.cs
index fb44fb6b..8ad74a75 100644
--- a/PARR.DAL/NextRunServices/INextRunService.cs
+++ b/PARR.DAL/NextRunServices/INextRunService.cs
@@ -20,20 +20,21 @@ namespace PARR.DAL.NextRunServices
         Task<List<TemplateNextRunResultDto>?> GetNextRunForJobGroupWithAutoDistributionAsync(Guid jobGroupId);
 
 
-        /// <summary>
-        /// Получить NextRun по jobGroupId с расписанием ЕСПП
-        /// </summary>
-        /// <param name="jobGroupId"></param>
-        /// <returns></returns>
-        Task<DateTimeOffset> GetNextRunForJobGroupWithEsppSchedulleAsync(Guid jobGroupId);
+        ///// <summary>
+        ///// Получить NextRun по jobGroupId с расписанием ЕСПП
+        ///// </summary>
+        ///// <param name="jobGroupId"></param>
+        ///// <returns></returns>
+        //Task<DateTimeOffset> GetNextRunForJobGroupWithEsppSchedulleAsync(Guid jobGroupId);
 
 
         /// <summary>
         /// Получить nextRun для создаваемого шаблона, которого еще нет в БД
         /// </summary>
         /// <param name="jobGroupId"></param>
+        /// <param name="responseArea">НЕ МАСКА, а прям ЗО</param>
         /// <returns></returns>
-        Task<DateTimeOffset> GetNextRunForNewTemplateAsync(Guid jobGroupId);
+        Task<DateTimeOffset> GetNextRunForNewTemplateAsync(Guid jobGroupId, string responseArea);
 
 
         /// <summary>
diff --git a/PARR.DAL/NextRunServices/NextRunService.cs b/PARR.DAL/NextRunServices/NextRunService.cs
index 19a6efb6..2009576e 100644
--- a/PARR.DAL/NextRunServices/NextRunService.cs
+++ b/PARR.DAL/NextRunServices/NextRunService.cs
@@ -1,6 +1,5 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using PARR.BLL.Helpers;
 using PARR.Constants;
 using PARR.DAL.Contracts;
 using PARR.DAL.DomainServices.Shortcodes;
@@ -8,7 +7,6 @@ using PARR.DAL.Models;
 using PARR.DAL.Models.Job;
 using PARR.DAL.NextRunServices.Models;
 using PARR.DAL.NextRunServices.Subservices;
-using PARR.DAL.Services.Implementations.Schedule;
 using PARR.DAL.Services.Interfaces;
 using PARR.DAL.Services.Interfaces.Job;
 using PARR.DAL.Services.Interfaces.Schedule;
@@ -136,22 +134,24 @@ namespace PARR.DAL.NextRunServices
         }
 
 
-        public async Task<DateTimeOffset> GetNextRunForJobGroupWithEsppSchedulleAsync(Guid jobGroupId)
-        {
-            var jobGroup = await jobGroupService.Get().AsNoTracking().FirstOrDefaultAsync(t => t.Id == jobGroupId);
+        //public async Task<DateTimeOffset> GetNextRunForJobGroupWithEsppSchedulleAsync(Guid jobGroupId)
+        //{
+        //    var jobGroup = await jobGroupService.Get().AsNoTracking().FirstOrDefaultAsync(t => t.Id == jobGroupId);
 
-            if (jobGroup == null)
-            {
-                logger.LogError("Не найдена группа работ с Id: {jobGroupId}.", jobGroupId);
-                throw new ArgumentNullException(nameof(jobGroupId), $"Не найдена группа работ с Id: {jobGroupId}");
-            }
+        //    if (jobGroup == null)
+        //    {
+        //        logger.LogError("Не найдена группа работ с Id: {jobGroupId}.", jobGroupId);
+        //        throw new ArgumentNullException(nameof(jobGroupId), $"Не найдена группа работ с Id: {jobGroupId}");
+        //    }
 
-            // Берем из обычного расписания ЕСПП
-            return await esppScheduleTransformService.GetNextDateAsync(jobGroupId, jobGroup.ReferenceDate);
-        }
+        //    // Берем из обычного расписания ЕСПП
+        //    //return await esppScheduleTransformService.GetNextDateAsync(jobGroupId, jobGroup.ReferenceDate);
+
+        //    return await GetNextRunForEsppStandardScheduleAsync(template);
+        //}
 
 
-        public async Task<DateTimeOffset> GetNextRunForNewTemplateAsync(Guid jobGroupId)
+        public async Task<DateTimeOffset> GetNextRunForNewTemplateAsync(Guid jobGroupId, string responseArea)
         {
             // определяю это автораспределение или нет, вызываю соответствующий рассчет
 
@@ -199,7 +199,8 @@ namespace PARR.DAL.NextRunServices
             else
             {
                 // тут расписание ЕСПП
-                var nextRun = await esppScheduleTransformService.GetNextDateAsync(jobGroup.Id, jobGroup.ReferenceDate);
+                //var nextRun = await esppScheduleTransformService.GetNextDateAsync(jobGroup.Id, jobGroup.ReferenceDate);
+                var nextRun = await GetNextRunForEsppStandardScheduleAsync(jobGroupId, jobGroup.ReferenceDate, jobGroup.IsResponseAreaTimezone, responseArea);
                 logger.LogDebug("Получил nextRun {nextRun} по jobGroupId {jobGroupId}, тип расписания ЕСПП", nextRun, jobGroupId);
 
                 return nextRun;
@@ -253,7 +254,13 @@ namespace PARR.DAL.NextRunServices
             else
             {
                 // считаем как ЕСПП
-                var nextRun = await esppScheduleTransformService.GetNextDateAsync(template.Job.Group.Id, template.Job.Group.ReferenceDate);
+                //var offset = GetOffsetTest();
+                //var nextRun = await esppScheduleTransformService.GetNextDateAsync(template.Job.Group.Id, template.Job.Group.ReferenceDate, offset);
+
+                //var nextRun = await GetNextRunForEsppStandardScheduleAsync(template.Job.Group.Id, template.Job.Group.ReferenceDate, template);
+                var responseArea = await shortcodesService.ApplyShortcodesAsync(template.Job.ResponseAreaMask, template);
+                var nextRun = await GetNextRunForEsppStandardScheduleAsync(template.Job.GroupId, template.Job.Group.ReferenceDate, template.Job.Group.IsResponseAreaTimezone, responseArea);
+
                 logger.LogDebug("Получил nextRun {nextRun} по templateId {templateId}, isNew: {isNew}, тип расписания: ЕСПП", nextRun, templateId, isNew);
 
                 return nextRun;
@@ -262,6 +269,31 @@ namespace PARR.DAL.NextRunServices
 
 
 
+        /// <summary>
+        /// Расчет nextRun по расписанию ЕСПП
+        /// </summary>
+        /// <param name="jobGroupId"></param>
+        /// <param name="referenceDate"></param>
+        /// <param name="template">Template with include Job, Group</param>
+        /// <returns></returns>
+        private async Task<DateTimeOffset> GetNextRunForEsppStandardScheduleAsync(Guid jobGroupId, DateTimeOffset referenceDate, bool isResponseAreaTimezone, string? responseArea)
+        {
+            //var isResponseAreaTimezone = template.Job?.Group?.IsResponseAreaTimezone ?? false;
+            //string? responseArea = null;
+
+            //if (isResponseAreaTimezone)
+            //{
+            //    var responseAreaMask = template.Job!.ResponseAreaMask;
+            //    responseArea = await shortcodesService.ApplyShortcodesAsync(responseAreaMask, template);
+            //}
+
+            var offset = GetTimeOffset(isResponseAreaTimezone, responseArea);
+            //var nextRun = await esppScheduleTransformService.GetNextDateAsync(template.Job!.GroupId, template.Job!.Group!.ReferenceDate, offset);
+            var nextRun = await esppScheduleTransformService.GetNextDateAsync(jobGroupId, referenceDate, offset);
+
+            return nextRun;
+        }
+
 
 
         /// <summary>
@@ -331,30 +363,79 @@ namespace PARR.DAL.NextRunServices
 
         public DateTimeOffset GetNextRunWithTimezoneEsppAndResponseArea(DateTimeOffset nextRun, bool? isResponseAreaTimezone = null, string? responseArea = null)
         {
-            logger.LogDebug("Начинаю получать nextRun с учетом УЗ ЕСПП и ЗО, входные параметры: nextRun: {nextRun}, isResponseAreaTimezone: {isResponseAreaTimezone}, responseArea: {responseArea}", nextRun, isResponseAreaTimezone, responseArea);
+            //logger.LogDebug("Начинаю получать nextRun с учетом УЗ ЕСПП и ЗО, входные параметры: nextRun: {nextRun}, isResponseAreaTimezone: {isResponseAreaTimezone}, responseArea: {responseArea}", nextRun, isResponseAreaTimezone, responseArea);
+
+            //var esppOffset = GetEsppAccountOffset();
+
+            //// смещение УЗ ЕСПП
+            //var resultNextRun = nextRun.Add(esppOffset);
+            //logger.LogDebug("Смещение nextRun с учетом смещения УЗ ЕСПП, новое значение: {resultNextRun}", resultNextRun);
+
+            //// если включено использовать таймзону ЗО
+            //if (isResponseAreaTimezone == true && !string.IsNullOrEmpty(responseArea))
+            //{
+            //    // resultNextRun = офсет УЗ ЕСПП - offset ЗО
+            //    var responseAreaOffset = scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea).UtcTimeOffset;
+
+            //    var resultOffset = esppOffset - responseAreaOffset;
+
+            //    resultNextRun = resultNextRun.Add(resultOffset);
+            //    logger.LogDebug("Смещение nextRun с учетом ЗО, смещение ЗО: {responseAreaOffset}, смещение с учетом смещения УЗ ЕСПП: {resultOffset}, новое значение: {resultNextRun}", responseAreaOffset, resultOffset, resultNextRun);
+            //}
+
+            ////var resulstStr = EsppScheduleHelpers.GetNextRun(resultNextRun);
+            ////logger.LogDebug("Результат в формате ЕСПП: {resulstStr}", resulstStr);
+
+            //return resultNextRun;
+
+            var offset = GetTimeOffset(isResponseAreaTimezone ?? false, responseArea);
+
+            return nextRun.Add(offset);
+        }
+
+        private TimeSpan GetTimeOffset(bool isResponseAreaTimezone, string? responseArea = null)
+        {
+            // logger.LogDebug("Начинаю получать nextRun с учетом УЗ ЕСПП и ЗО, входные параметры: nextRun: {nextRun}, isResponseAreaTimezone: {isResponseAreaTimezone}, responseArea: {responseArea}", nextRun, isResponseAreaTimezone, responseArea);
 
             var esppOffset = GetEsppAccountOffset();
 
-            // смещение УЗ ЕСПП
-            var resultNextRun = nextRun.Add(esppOffset);
-            logger.LogDebug("Смещение nextRun с учетом смещения УЗ ЕСПП, новое значение: {resultNextRun}", resultNextRun);
+            logger.LogDebug("Получил оффсет {esppOffset}, для параметров: isResponseAreaTimezone: {isResponseAreaTimezone}, responseArea: {responseArea}", esppOffset, isResponseAreaTimezone, responseArea);
 
-            // если включено использовать таймзону ЗО
-            if (isResponseAreaTimezone == true && !string.IsNullOrEmpty(responseArea))
-            {
-                // resultNextRun = офсет УЗ ЕСПП - offset ЗО
-                var responseAreaOffset = scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea).UtcTimeOffset;
+            //if (isResponseAreaTimezone == true && !string.IsNullOrEmpty(responseArea))
+            //{
+            //    // resultNextRun = офсет УЗ ЕСПП - offset ЗО
+            //    var responseAreaOffset = scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea).UtcTimeOffset;
 
-                var resultOffset = esppOffset - responseAreaOffset;
+            //    var resultOffset = esppOffset- responseAreaOffset;
 
-                resultNextRun = resultNextRun.Add(resultOffset);
-                logger.LogDebug("Смещение nextRun с учетом ЗО, смещение ЗО: {responseAreaOffset}, смещение с учетом смещения УЗ ЕСПП: {resultOffset}, новое значение: {resultNextRun}", responseAreaOffset, resultOffset, resultNextRun);
-            }
+            //    return resultOffset;
+            //    //logger.LogDebug("Смещение nextRun с учетом ЗО, смещение ЗО: {responseAreaOffset}, смещение с учетом смещения УЗ ЕСПП: {resultOffset}, новое значение: {resultNextRun}", responseAreaOffset, resultOffset, resultNextRun);
+            //}
 
-            //var resulstStr = EsppScheduleHelpers.GetNextRun(resultNextRun);
-            //logger.LogDebug("Результат в формате ЕСПП: {resulstStr}", resulstStr);
+            return esppOffset;
 
-            return resultNextRun;
+            // var resultOffset = 
+
+            //// смещение УЗ ЕСПП
+            //var resultNextRun = nextRun.Add(esppOffset);
+            //logger.LogDebug("Смещение nextRun с учетом смещения УЗ ЕСПП, новое значение: {resultNextRun}", resultNextRun);
+
+            //// если включено использовать таймзону ЗО
+            //if (isResponseAreaTimezone == true && !string.IsNullOrEmpty(responseArea))
+            //{
+            //    // resultNextRun = офсет УЗ ЕСПП - offset ЗО
+            //    var responseAreaOffset = scheduleResponseAreaTimeOffsetService.GetByResponseAreaOrDefault(responseArea).UtcTimeOffset;
+
+            //    var resultOffset = esppOffset - responseAreaOffset;
+
+            //    resultNextRun = resultNextRun.Add(resultOffset);
+            //    logger.LogDebug("Смещение nextRun с учетом ЗО, смещение ЗО: {responseAreaOffset}, смещение с учетом смещения УЗ ЕСПП: {resultOffset}, новое значение: {resultNextRun}", responseAreaOffset, resultOffset, resultNextRun);
+            //}
+
+            ////var resulstStr = EsppScheduleHelpers.GetNextRun(resultNextRun);
+            ////logger.LogDebug("Результат в формате ЕСПП: {resulstStr}", resulstStr);
+
+            //return resultNextRun;
         }
 
         public DateTimeOffset GetNextRunWithResponseAreaOffset(DateTimeOffset nextRun, string responseArea)
diff --git a/PARR.DAL/NextRunServices/Subservices/EsppScheduleTransformService.cs b/PARR.DAL/NextRunServices/Subservices/EsppScheduleTransformService.cs
index a700eece..069a992b 100644
--- a/PARR.DAL/NextRunServices/Subservices/EsppScheduleTransformService.cs
+++ b/PARR.DAL/NextRunServices/Subservices/EsppScheduleTransformService.cs
@@ -60,21 +60,31 @@ namespace PARR.DAL.NextRunServices.Subservices
             this.logger = logger;
         }
 
-        public async Task<DateTimeOffset> GetNextDateAsync(Guid jobGroupId, DateTimeOffset referenceDate)
+        public async Task<DateTimeOffset> GetNextDateAsync(Guid jobGroupId, DateTimeOffset referenceDate, TimeSpan? offset = null)
         {
             var esppSchedule = await GetEsppScheduleAsync(jobGroupId);
 
-            return GetNextDate(esppSchedule, referenceDate);
+            return GetNextDate(esppSchedule, referenceDate, offset);
         }
 
-        private DateTimeOffset GetNextDate(EsppScheduleDto esppSchedule, DateTimeOffset referenceDate)
+        private DateTimeOffset GetNextDate(EsppScheduleDto esppSchedule, DateTimeOffset referenceDate, TimeSpan? offset)
         {
             var nextRun = referenceDate;
 
-            //---------
-            // Для рассчета по МСК времени, потому что в ЮТС может быть еще ВСК, а по МСК это уже ПНД
-            var offsetReferenceDate = referenceDate.ToOffset(new TimeSpan(3, 0, 0));
-            //---------
+            var finalOffset = new TimeSpan(3, 0, 0) + offset ?? TimeSpan.Zero;
+
+            var offsetReferenceDate = referenceDate.ToOffset(finalOffset);
+
+            ////---------
+            //// Для рассчета по МСК времени, потому что в ЮТС может быть еще ВСК, а по МСК это уже ПНД
+            //var offsetReferenceDate = referenceDate.ToOffset(new TimeSpan(3, 0, 0));
+            ////---------
+
+            //// может быть offset ,это работает когда смещение для УЗ ЕСПП и применение ЗО РГ
+            //if (offset.HasValue)
+            //    offsetReferenceDate = offsetReferenceDate.Off(offsetReferenceDate.Offset + offset);
+            //    //offsetReferenceDate = offsetReferenceDate.Add(offset.Value);
+
 
             switch (esppSchedule.TypeSchedule.Id)
             {
diff --git a/PARR.DAL/NextRunServices/Subservices/IEsppScheduleTransformService.cs b/PARR.DAL/NextRunServices/Subservices/IEsppScheduleTransformService.cs
index 354e11b1..4a197589 100644
--- a/PARR.DAL/NextRunServices/Subservices/IEsppScheduleTransformService.cs
+++ b/PARR.DAL/NextRunServices/Subservices/IEsppScheduleTransformService.cs
@@ -27,7 +27,7 @@
         /// <param name="jobGroupId"></param>
         /// <param name="lastRun"></param>
         /// <returns></returns>
-        Task<DateTimeOffset> GetNextDateAsync(Guid jobGroupId, DateTimeOffset lastRun);
+        Task<DateTimeOffset> GetNextDateAsync(Guid jobGroupId, DateTimeOffset lastRun, TimeSpan? offset = null);
 
         ///// <summary>
         ///// Получить расписание по jobGroupId
diff --git a/PARR.NextRun/NextRunManager.cs b/PARR.NextRun/NextRunManager.cs
index a3a1b6d7..f075aa8a 100644
--- a/PARR.NextRun/NextRunManager.cs
+++ b/PARR.NextRun/NextRunManager.cs
@@ -62,16 +62,56 @@ namespace PARR.NextRun
         {
             logger.LogInformation("Начинаю обновлять NextRun по расписанию");
 
-            // обновляем для групп у которых не включено автораспределение
-            await UpdateNextRunWithEsppScheduleAsync(templateService, nextRunService, jobGroupService);
+            //// обновляем для групп у которых не включено автораспределение
+            //await UpdateNextRunWithEsppScheduleAsync(templateService, nextRunService, jobGroupService);
 
-            // для групп у которых включено автораспределение
-            await UpdateNextRunWithAutodistributeScheduleAsync(templateService, nextRunService, jobGroupService);
+            //// для групп у которых включено автораспределение
+            //await UpdateNextRunWithAutodistributeScheduleAsync(templateService, nextRunService, jobGroupService);
+
+            await UpdateNextRunAsync(templateService, nextRunService, jobGroupService);
 
             logger.LogInformation($"Завершено обновление полей NextRun.");
         }
 
 
+        private async Task UpdateNextRunAsync(ITemplateService templateService, INextRunService nextRunService, IJobGroupService jobGroupService)
+        {
+            // выбираем все шаблоны с просроченным nextRun в статусе Used
+
+            var templatesForUpdate = await templateService.Get()
+                                       .Where(t =>
+                                           t.StatusTypeId == TemplateStatusTypeEnum.Used
+                                           && t.NextRun < DateTimeOffset.UtcNow
+                                       ).ToListAsync();
+
+            logger.LogInformation("Найдено шаблонов в статусе Used с просроченным NextRun {count} шт.", templatesForUpdate.Count);
+
+            if (!templatesForUpdate.Any())
+                return;
+
+
+            foreach (var template in templatesForUpdate)
+            {
+                var newNextRun = await nextRunService.GetNextRunForTemplateAsync(template.Id, false);
+
+                template.LastRun = template.NextRun;
+                template.NextRun = newNextRun;
+            }
+
+            if (await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Обновлён NextRun", InitiatorParrComponentId = ParrComponentsEnum.NextRun }))
+            {
+                logger.LogInformation("Обновлены значения полей NextRun для шаблонов в статусе Used, {count} шт.", templatesForUpdate.Count);
+            }
+            else
+            {
+                logger.LogError("Ошибка при обновлении значений полей NextRun, для шаблонов в статусе Used, {count} шт.", templatesForUpdate.Count);
+            }
+
+        }
+
+
+        #region old
+
         /// <summary>
         /// Обновить nextRun для ВСЕХ шаблонов, для групп у которых расписание ЕСПП (выключено автораспределение)
         /// </summary>
@@ -80,50 +120,87 @@ namespace PARR.NextRun
         {
             // выбираем шаблоны которые не учавствуют в автораспределении
             // и у которых Used
-            // затем группируем по GroupId, так как nextRun и расписание настраивается для группы, то для всех дочерних шаблонов, nextRun будет одинаковым
             // обновляем для всех шаблонов, у которых nextRun!=рассчитанному
 
+            var templatesForUpdate = await templateService.Get()
+                                        .Where(t =>
+                                            t.StatusTypeId == TemplateStatusTypeEnum.Used
+                                            && t.Job!.Group!.IsAutoDistributionEnabled == false
+                                            && t.NextRun < DateTimeOffset.UtcNow
+                                        ).ToListAsync();
 
-            var groups = await jobGroupService.Get()
-                                    .Where(t => t.IsAutoDistributionEnabled == false)
-                                    .Select(t => new { t.Id, t.ReferenceDate })
-                                    .ToListAsync();
 
-            logger.LogInformation("Найдено {GroupCount} групп с выключенным автораспределением для обработки.", groups.Count);
+            logger.LogInformation("Найдено шаблонов с выключенным автораспределением, с просроченным NextRun {count} шт.", templatesForUpdate.Count);
 
-            foreach (var group in groups)
+            if (!templatesForUpdate.Any())
+                return;
+
+            foreach (var template in templatesForUpdate)
             {
-                //получаем по каждой группе следующий nextRun и сравниваем с существующим, если не равны, то обновляем
-                //var nextRun = await esppScheduleTransformService.GetNextDateAsync(group.Id, group.ReferenceDate);
-                var nextRun = await nextRunService.GetNextRunForJobGroupWithEsppSchedulleAsync(group.Id);
+                var newNextRun = await nextRunService.GetNextRunForTemplateAsync(template.Id, false);
 
-
-                // Загружаем только шаблоны текущей группы где nextRun в БД не равен расчетному
-                var templatesToUpdate = await templateService.Get()
-                                        .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Used && t.Job!.GroupId == group.Id && t.NextRun != nextRun)
-                                        .ToListAsync();
-
-                logger.LogInformation("Для группы {groupId}, шаблонов для обновления где nextRun!=рассчетному {newNextRun} найдено {count} шт.", group.Id, nextRun, templatesToUpdate.Count);
-
-                if (!templatesToUpdate.Any())
-                    continue;
-
-                // Обновляем
-                foreach (var template in templatesToUpdate)
-                {
-                    template.LastRun = template.NextRun;
-                    template.NextRun = nextRun;
-                }
-
-                // Коммитим изменения для этой группы
-                if (await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Обновлён NextRun", InitiatorParrComponentId = ParrComponentsEnum.NextRun }))
-                    logger.LogInformation($"Обновлены значения полей NextRun для шаблонов группы: {group.Id} с выключенным автораспределением, " +
-                        $"refDate: {group.ReferenceDate}. Обновлен nextRun: {nextRun} для шаблонов {templatesToUpdate.Count} шт.");
-                else
-                {
-                    logger.LogError($"Ошибка при обновлении значений полей NextRun: {nextRun}, для шаблонов {templatesToUpdate.Count} шт., группы {group.Id} с выключенным автораспределением, refDate: {group.ReferenceDate} ");
-                }
+                template.LastRun = template.NextRun;
+                template.NextRun = newNextRun;
             }
+
+            if (await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Обновлён NextRun", InitiatorParrComponentId = ParrComponentsEnum.NextRun }))
+            {
+                logger.LogInformation("Обновлены значения ПРОСРОЧЕННЫХ полей NextRun для шаблонов с ВЫКЛЮЧЕННЫМ автораспределением, {count} шт.", templatesForUpdate.Count);
+            }
+            else
+            {
+                logger.LogError("Ошибка при обновлении ПРОСРОЧЕННЫХ значений полей NextRun, для шаблонов {count} шт., с ВЫКЛЮЧЕННЫМ автораспределением", templatesForUpdate.Count);
+            }
+
+
+           
+            //// выбираем шаблоны которые не учавствуют в автораспределении
+            //// и у которых Used
+            //// затем группируем по GroupId, так как nextRun и расписание настраивается для группы, то для всех дочерних шаблонов, nextRun будет одинаковым
+            //// обновляем для всех шаблонов, у которых nextRun!=рассчитанному
+
+
+            //var groups = await jobGroupService.Get()
+            //                        .Where(t => t.IsAutoDistributionEnabled == false)
+            //                        .Select(t => new { t.Id, t.ReferenceDate })
+            //                        .ToListAsync();
+
+            //logger.LogInformation("Найдено {GroupCount} групп с выключенным автораспределением для обработки.", groups.Count);
+
+            //foreach (var group in groups)
+            //{
+            //    //получаем по каждой группе следующий nextRun и сравниваем с существующим, если не равны, то обновляем
+            //    //var nextRun = await esppScheduleTransformService.GetNextDateAsync(group.Id, group.ReferenceDate);
+            //    var nextRun = await nextRunService.GetNextRunForJobGroupWithEsppSchedulleAsync(group.Id);
+
+
+            //    // Загружаем только шаблоны текущей группы где nextRun в БД не равен расчетному
+            //    var templatesToUpdate = await templateService.Get()
+            //                            .Where(t => t.StatusTypeId == TemplateStatusTypeEnum.Used && t.Job!.GroupId == group.Id && t.NextRun != nextRun)
+            //                            .ToListAsync();
+
+            //    logger.LogInformation("Для группы {groupId}, шаблонов для обновления где nextRun!=рассчетному {newNextRun} найдено {count} шт.", group.Id, nextRun, templatesToUpdate.Count);
+
+            //    if (!templatesToUpdate.Any())
+            //        continue;
+
+            //    // Обновляем
+            //    foreach (var template in templatesToUpdate)
+            //    {
+            //        template.LastRun = template.NextRun;
+            //        template.NextRun = nextRun;
+            //    }
+
+            //    // Коммитим изменения для этой группы
+            //    if (await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Обновлён NextRun", InitiatorParrComponentId = ParrComponentsEnum.NextRun }))
+            //        logger.LogInformation($"Обновлены значения полей NextRun для шаблонов группы: {group.Id} с выключенным автораспределением, " +
+            //            $"refDate: {group.ReferenceDate}. Обновлен nextRun: {nextRun} для шаблонов {templatesToUpdate.Count} шт.");
+            //    else
+            //    {
+            //        logger.LogError($"Ошибка при обновлении значений полей NextRun: {nextRun}, для шаблонов {templatesToUpdate.Count} шт., группы {group.Id} с выключенным автораспределением, refDate: {group.ReferenceDate} ");
+            //    }
+            //}
+           
         }
 
 
@@ -165,5 +242,7 @@ namespace PARR.NextRun
                 logger.LogError("Ошибка при обновлении ПРОСРОЧЕННЫХ значений полей NextRun, для шаблонов {count} шт., с ВКЛЮЧЕННЫМ автораспределением", templatesForUpdate.Count);
             }
         }
+
+        #endregion
     }
 }
diff --git a/PARR.NextRunWorker/appsettings.Development.json b/PARR.NextRunWorker/appsettings.Development.json
index b2733ea8..71c186b7 100644
--- a/PARR.NextRunWorker/appsettings.Development.json
+++ b/PARR.NextRunWorker/appsettings.Development.json
@@ -4,13 +4,13 @@
   },
   "Logging": {
     "LogLevel": {
-      "Default": "Information",
+      "Default": "Debug",
       "Microsoft.Hosting.Lifetime": "Information"
     }
   },
   "Serilog": {
     "MinimumLevel": {
-      "Default": "Information",
+      "Default": "Debug",
       "Override": {
         "Microsoft": "Warning",
         "Microsoft.Hosting.Lifetime": "Information"
diff --git a/PARR.TemplateGeneratorWorker/TemplateGenerator.cs b/PARR.TemplateGeneratorWorker/TemplateGenerator.cs
index 219b9ca0..4c69acc8 100644
--- a/PARR.TemplateGeneratorWorker/TemplateGenerator.cs
+++ b/PARR.TemplateGeneratorWorker/TemplateGenerator.cs
@@ -98,8 +98,9 @@ namespace PARR.TemplateGeneratorWorker
 
             var templateName = await shortcodesService.ApplyShortcodesAsync(job.TemplateNameMask!, tempTemplateForShortcodes);
 
+            var responseArea = await shortcodesService.ApplyShortcodesAsync(job.ResponseAreaMask, tempTemplateForShortcodes);
             //var nextRun = await esppScheduleTransformService.GetNextDateAsync(job.GroupId, job.Group!.ReferenceDate);
-            var nextRun = await nextRunService.GetNextRunForNewTemplateAsync(job.GroupId);
+            var nextRun = await nextRunService.GetNextRunForNewTemplateAsync(job.GroupId, responseArea);
 
             var template = new Template
             {
diff --git a/PARR.Test/NextRun/NextRunTest.cs b/PARR.Test/NextRun/NextRunTest.cs
index cbb596a2..afaa3c1a 100644
--- a/PARR.Test/NextRun/NextRunTest.cs
+++ b/PARR.Test/NextRun/NextRunTest.cs
@@ -1,6 +1,10 @@
-using PARR.DAL.NextRunServices;
+using Microsoft.EntityFrameworkCore;
+using PARR.DAL.DomainServices.Shortcodes;
+using PARR.DAL.NextRunServices;
 using PARR.DAL.NextRunServices.Models;
 using PARR.DAL.NextRunServices.Subservices;
+using PARR.DAL.Services.Interfaces;
+using System.Threading.Tasks;
 
 namespace PARR.Test.NextRun
 {
@@ -8,11 +12,15 @@ namespace PARR.Test.NextRun
     {
         //private readonly ITemplateDistributor templateDistributor;
         private readonly INextRunService nextRunService;
+        private readonly ITemplateService templateService;
+        private readonly IShortcodesService shortcodesService;
 
-        public NextRunTest(/*ITemplateDistributor templateDistributor, */INextRunService nextRunService)
+        public NextRunTest(/*ITemplateDistributor templateDistributor, */INextRunService nextRunService, ITemplateService templateService, IShortcodesService shortcodesService)
         {
             //this.templateDistributor = templateDistributor;
             this.nextRunService = nextRunService;
+            this.templateService = templateService;
+            this.shortcodesService = shortcodesService;
         }
 
         int periodDays = 10;
@@ -20,6 +28,24 @@ namespace PARR.Test.NextRun
 
         public async Task Test()
         {
+            //var template = await templateService.Get().Include(t => t.Job).ThenInclude(t => t.Group).FirstAsync(t => t.Name == "ЭИТИ-ПАРР_ЦКИТ-ГВЦ_СХД ТО-1_СХД-AERODISK-432-2-4-U26-EN4SAG022-ГВЦ");
+            //var responseAreae = await shortcodesService.ApplyShortcodesAsync(template.Job.ResponseAreaMask, template);
+            //var nextRunWithTimezone = nextRunService.GetNextRunWithTimezoneEsppAndResponseArea(template.NextRun, template.Job?.Group?.IsResponseAreaTimezone, responseAreae);
+
+            //DateTimeOffset dbNextRun = new DateTimeOffset(2026, 2, 2, 4, 0, 0, TimeSpan.Zero);
+            //var result = nextRunService.GetNextRunWithTimezoneEsppAndResponseArea(dbNextRun, true, "96-ДВС");
+
+            //var template = await templateService.Get()
+            //                            .AsNoTracking()
+            //                            .FirstAsync(t => t.Name == "ЭИТИ-ПАРР_ЦКИТ-ДВС_ТО-1 ОСМОТР ОБОРУД. (15-29 СТОЕК)_СРВ-МАШЗАЛ-315-01-ДВС");
+
+            //var newNextRun = await nextRunService.GetNextRunForTemplateAsync(template.Id, false);
+
+            //var esppResult = nextRunService.GetNextRunWithTimezoneEsppAndResponseArea(newNextRun, true, "96-ДВС");
+
+
+
+
             // GetWorkDaysTESTAsync
             //var aaa = await templateDistributor.GetWorkDaysTESTAsync(GetDateStart(), GetDateStart().AddDays(periodDays), true, referenceDate);
 
@@ -66,7 +92,7 @@ namespace PARR.Test.NextRun
             // исключать выходные и праздники
             var excludeWeekends = true;
 
-           // var templates = await templateDistributor.DistributeTemplatesAsync(GetDateStart(), periodDays, referenceDate, GetTemplates(), excludeWeekends);
+            // var templates = await templateDistributor.DistributeTemplatesAsync(GetDateStart(), periodDays, referenceDate, GetTemplates(), excludeWeekends);
 
             //await GetValidNextRunForTemplateAsync(templates);
         }