From 5094945c8e63b566cc6edd277f557044d883ca1a Mon Sep 17 00:00:00 2001
From: Mikhail Trubnikov <ivc_trubnikovme@dvgd.rzd>
Date: Tue, 21 Jul 2026 11:48:21 +1000
Subject: [PATCH] =?UTF-8?q?feat(dal,domain):=20=D0=A2=D0=B0=D0=B1=D0=BB?=
 =?UTF-8?q?=D0=B8=D1=86=D1=8B=20=D1=80=D0=BE=D0=B1=D0=BE=D1=82=D0=BE=D0=B2?=
 =?UTF-8?q?=20=D0=BF=D0=B5=D1=80=D0=B5=D0=BD=D0=B5=D1=81=D0=B5=D0=BD=D1=8B?=
 =?UTF-8?q?=20=D0=B2=20=D1=81=D1=85=D0=B5=D0=BC=D1=83=20robot.=20=D0=A1?=
 =?UTF-8?q?=D0=BE=D0=B7=D0=B4=D0=B0=D0=BD=D0=B0=20=D1=82=D0=B0=D0=B1=D0=BB?=
 =?UTF-8?q?=D0=B8=D1=86=D0=B0=20TemplateRenamePendings=20-=20=D0=A8=D0=B0?=
 =?UTF-8?q?=D0=B1=D0=BB=D0=BE=D0=BD=D1=8B=20=D0=BD=D0=B0=D1=85=D0=BE=D0=B4?=
 =?UTF-8?q?=D1=8F=D1=89=D0=B8=D0=B5=D1=81=D1=8F=20=D0=B2=20=D0=BF=D1=80?=
 =?UTF-8?q?=D0=BE=D1=86=D0=B5=D1=81=D1=81=D0=B5=20=D0=BF=D0=B5=D1=80=D0=B5?=
 =?UTF-8?q?=D0=B8=D0=BC=D0=B5=D0=BD=D0=BE=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Controllers/V1/RobotHistoryController.cs  |    2 +-
 .../V1/RobotTaskRobotStatusController.cs      |    1 +
 .../Statistics/StatRobotHistoryController.cs  |    2 +-
 .../Middleware/GlobalExceptionHandler.cs      |    2 +-
 .../DomainToResponseProfile.cs                |    5 +-
 .../IRobotHistoryLevelRepository.cs           |    2 +-
 .../Interfaces/IRobotHistoryRepository.cs     |    2 +-
 .../Interfaces/IRobotRepository.cs            |    2 +-
 .../Interfaces/IRobotStatusRepository.cs      |    2 +-
 .../Interfaces/IStatusTemplateRepository.cs   |    2 +-
 .../Interfaces/ITaskStatusRepository.cs       |    2 +-
 .../Implementations/RobotTaskService.cs       |    1 +
 PARR.DAL/Context/DataContext.cs               |   42 +-
 PARR.DAL/DependencyInjection.cs               |    5 +-
 ...20233522_tblRobotsUpdateScheme.Designer.cs | 4096 ++++++++++++++++
 .../20260720233522_tblRobotsUpdateScheme.cs   |   68 +
 ...20260720233632_tblRobotsRename.Designer.cs | 4096 ++++++++++++++++
 .../20260720233632_tblRobotsRename.cs         |  222 +
 ...3444_tblTemplateRenamePendings.Designer.cs | 4133 +++++++++++++++++
 ...0260721013444_tblTemplateRenamePendings.cs |   54 +
 .../Migrations/DataContextModelSnapshot.cs    |  343 +-
 .../RobotHistoryLevelRepository.cs            |    2 +-
 .../Repositories/RobotHistoryRepository.cs    |    2 +-
 PARR.DAL/Repositories/RobotRepository.cs      |    2 +-
 .../Repositories/RobotStatusRepository.cs     |    2 +-
 .../Repositories/StatusTemplateRepository.cs  |    2 +-
 PARR.DAL/Repositories/TaskStatusRepository.cs |    2 +-
 PARR.Domain/Constants/DatabaseSchemas.cs      |   11 +-
 PARR.Domain/Entities/RobotConfiguration.cs    |    3 +-
 .../Entities/{ => RobotEntities}/Robot.cs     |    6 +-
 .../{ => RobotEntities}/RobotHistory.cs       |    6 +-
 .../{ => RobotEntities}/RobotHistoryLevel.cs  |   11 +-
 .../{ => RobotEntities}/RobotStatus.cs        |    6 +-
 .../{ => RobotEntities}/TaskStatus.cs         |    6 +-
 PARR.Domain/Entities/Template.cs              |    3 +
 .../TemplateEntities/TemplateRenamePending.cs |   31 +
 36 files changed, 12965 insertions(+), 214 deletions(-)
 create mode 100644 PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.Designer.cs
 create mode 100644 PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.cs
 create mode 100644 PARR.DAL/Migrations/20260720233632_tblRobotsRename.Designer.cs
 create mode 100644 PARR.DAL/Migrations/20260720233632_tblRobotsRename.cs
 create mode 100644 PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.Designer.cs
 create mode 100644 PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.cs
 rename PARR.Domain/Entities/{ => RobotEntities}/Robot.cs (83%)
 rename PARR.Domain/Entities/{ => RobotEntities}/RobotHistory.cs (90%)
 rename PARR.Domain/Entities/{ => RobotEntities}/RobotHistoryLevel.cs (64%)
 rename PARR.Domain/Entities/{ => RobotEntities}/RobotStatus.cs (83%)
 rename PARR.Domain/Entities/{ => RobotEntities}/TaskStatus.cs (86%)
 create mode 100644 PARR.Domain/Entities/TemplateEntities/TemplateRenamePending.cs

diff --git a/PARR.API/Controllers/V1/RobotHistoryController.cs b/PARR.API/Controllers/V1/RobotHistoryController.cs
index ce1a3090..9ff43aa8 100644
--- a/PARR.API/Controllers/V1/RobotHistoryController.cs
+++ b/PARR.API/Controllers/V1/RobotHistoryController.cs
@@ -14,7 +14,7 @@ using PARR.API.Services.Interfaces;
 using PARR.Core.Repositories.Interfaces;
 using PARR.Domain.Common.Pagination;
 using PARR.Domain.Common.Roles;
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.API.Controllers.V1
 {
diff --git a/PARR.API/Controllers/V1/RobotTaskRobotStatusController.cs b/PARR.API/Controllers/V1/RobotTaskRobotStatusController.cs
index 3d1246ff..91918a33 100644
--- a/PARR.API/Controllers/V1/RobotTaskRobotStatusController.cs
+++ b/PARR.API/Controllers/V1/RobotTaskRobotStatusController.cs
@@ -11,6 +11,7 @@ using PARR.API.Services.Interfaces;
 using PARR.Core.Repositories.Interfaces;
 using PARR.Domain.Common.Roles;
 using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 using PARR.Domain.Enums;
 
 namespace PARR.API.Controllers.V1
diff --git a/PARR.API/Controllers/V1/Statistics/StatRobotHistoryController.cs b/PARR.API/Controllers/V1/Statistics/StatRobotHistoryController.cs
index bdf07f33..34b11b1e 100644
--- a/PARR.API/Controllers/V1/Statistics/StatRobotHistoryController.cs
+++ b/PARR.API/Controllers/V1/Statistics/StatRobotHistoryController.cs
@@ -12,7 +12,7 @@ using PARR.API.Controllers.V1.Base;
 using PARR.API.Helpers;
 using PARR.Core.Repositories.Interfaces;
 using PARR.Domain.Common.Roles;
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.API.Controllers.V1.Statistics
 {
diff --git a/PARR.API/Infrastructure/Middleware/GlobalExceptionHandler.cs b/PARR.API/Infrastructure/Middleware/GlobalExceptionHandler.cs
index 1b202511..91cc75c4 100644
--- a/PARR.API/Infrastructure/Middleware/GlobalExceptionHandler.cs
+++ b/PARR.API/Infrastructure/Middleware/GlobalExceptionHandler.cs
@@ -18,7 +18,7 @@ namespace PARR.API.Infrastructure.Middleware
 
         public async ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken)
         {
-            logger.LogError(exception, "Ошибка во время запроса {TraceId}: {Message}", httpContext.TraceIdentifier, exception.Message);
+            logger.LogDebug(exception, "Ошибка во время запроса {TraceId}: {Message}", httpContext.TraceIdentifier, exception.Message);
 
             // определяем статус код, в зависимости от типа исключения
 
diff --git a/PARR.API/MappingProfiles/DomainToResponseProfile.cs b/PARR.API/MappingProfiles/DomainToResponseProfile.cs
index 604125c4..82b1d151 100644
--- a/PARR.API/MappingProfiles/DomainToResponseProfile.cs
+++ b/PARR.API/MappingProfiles/DomainToResponseProfile.cs
@@ -16,6 +16,7 @@ using PARR.Domain.Entities;
 using PARR.Domain.Entities.Base.History;
 using PARR.Domain.Entities.JobEntities;
 using PARR.Domain.Entities.JobGroupEntities;
+using PARR.Domain.Entities.RobotEntities;
 using PARR.Domain.Entities.Schedule;
 using PARR.Domain.Entities.Unit;
 
@@ -79,7 +80,7 @@ namespace PARR.API.MappingProfiles
                 .ForMember(d => d.Script, o => o.MapFrom(s => s.AgentScript))
                 .ForMember(d => d.TimeOutSec, o => o.MapFrom(s => s.AgentTimeOutSec));
 
-            CreateMap<PARR.Domain.Entities.TaskStatus, TaskStatusResponse>();
+            CreateMap<PARR.Domain.Entities.RobotEntities.TaskStatus, TaskStatusResponse>();
 
             #region ScheduleResponseAreaTimeOffsetResponse
 
@@ -255,7 +256,7 @@ namespace PARR.API.MappingProfiles
 
             CreateMap<Robot, RobotResponse>();
 
-            CreateMap<PARR.Domain.Entities.TaskStatus, TaskStatusResponse>();
+            CreateMap<PARR.Domain.Entities.RobotEntities.TaskStatus, TaskStatusResponse>();
 
             CreateMap<RobotConfiguration, RobotConfigurationResponse>()
                 .ForMember(d => d.Robot, o => o.MapFrom(s => s.Robot))
diff --git a/PARR.Core/Repositories/Interfaces/IRobotHistoryLevelRepository.cs b/PARR.Core/Repositories/Interfaces/IRobotHistoryLevelRepository.cs
index 7099934f..889159f1 100644
--- a/PARR.Core/Repositories/Interfaces/IRobotHistoryLevelRepository.cs
+++ b/PARR.Core/Repositories/Interfaces/IRobotHistoryLevelRepository.cs
@@ -1,4 +1,4 @@
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.Core.Repositories.Interfaces
 {
diff --git a/PARR.Core/Repositories/Interfaces/IRobotHistoryRepository.cs b/PARR.Core/Repositories/Interfaces/IRobotHistoryRepository.cs
index 755f501c..df718973 100644
--- a/PARR.Core/Repositories/Interfaces/IRobotHistoryRepository.cs
+++ b/PARR.Core/Repositories/Interfaces/IRobotHistoryRepository.cs
@@ -1,5 +1,5 @@
 using PARR.Core.Repositories.Base;
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.Core.Repositories.Interfaces
 {
diff --git a/PARR.Core/Repositories/Interfaces/IRobotRepository.cs b/PARR.Core/Repositories/Interfaces/IRobotRepository.cs
index be9fff60..d3a6f64d 100644
--- a/PARR.Core/Repositories/Interfaces/IRobotRepository.cs
+++ b/PARR.Core/Repositories/Interfaces/IRobotRepository.cs
@@ -1,4 +1,4 @@
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.Core.Repositories.Interfaces
 {
diff --git a/PARR.Core/Repositories/Interfaces/IRobotStatusRepository.cs b/PARR.Core/Repositories/Interfaces/IRobotStatusRepository.cs
index 921e7996..de80b5a6 100644
--- a/PARR.Core/Repositories/Interfaces/IRobotStatusRepository.cs
+++ b/PARR.Core/Repositories/Interfaces/IRobotStatusRepository.cs
@@ -1,4 +1,4 @@
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.Core.Repositories.Interfaces
 {
diff --git a/PARR.Core/Repositories/Interfaces/IStatusTemplateRepository.cs b/PARR.Core/Repositories/Interfaces/IStatusTemplateRepository.cs
index 0167027d..5742a0ce 100644
--- a/PARR.Core/Repositories/Interfaces/IStatusTemplateRepository.cs
+++ b/PARR.Core/Repositories/Interfaces/IStatusTemplateRepository.cs
@@ -2,6 +2,6 @@
 {
     public interface IStatusTemplateRepository
     {
-        IQueryable<Domain.Entities.TaskStatus> Get();
+        IQueryable<Domain.Entities.RobotEntities.TaskStatus> Get();
     }
 }
diff --git a/PARR.Core/Repositories/Interfaces/ITaskStatusRepository.cs b/PARR.Core/Repositories/Interfaces/ITaskStatusRepository.cs
index 43e73ff1..c8a64319 100644
--- a/PARR.Core/Repositories/Interfaces/ITaskStatusRepository.cs
+++ b/PARR.Core/Repositories/Interfaces/ITaskStatusRepository.cs
@@ -2,6 +2,6 @@
 {
     public interface ITaskStatusRepository
     {
-        IQueryable<Domain.Entities.TaskStatus> Get();
+        IQueryable<Domain.Entities.RobotEntities.TaskStatus> Get();
     }
 }
diff --git a/PARR.Core/Services/RobotTask/Implementations/RobotTaskService.cs b/PARR.Core/Services/RobotTask/Implementations/RobotTaskService.cs
index 6f0b9249..a10536b5 100644
--- a/PARR.Core/Services/RobotTask/Implementations/RobotTaskService.cs
+++ b/PARR.Core/Services/RobotTask/Implementations/RobotTaskService.cs
@@ -9,6 +9,7 @@ using PARR.Core.Services.Shortcodes;
 using PARR.Domain.DTOs.RobotTask;
 using PARR.Domain.Entities;
 using PARR.Domain.Entities.Base.History;
+using PARR.Domain.Entities.RobotEntities;
 using PARR.Domain.Enums;
 using PARR.Domain.Exceptions;
 using PARR.Domain.Settings;
diff --git a/PARR.DAL/Context/DataContext.cs b/PARR.DAL/Context/DataContext.cs
index eb645f08..352e91ae 100644
--- a/PARR.DAL/Context/DataContext.cs
+++ b/PARR.DAL/Context/DataContext.cs
@@ -8,6 +8,7 @@ using PARR.Domain.Entities.JobGroupEntities;
 using PARR.Domain.Entities.RobotEntities;
 using PARR.Domain.Entities.Schedule;
 using PARR.Domain.Entities.TaskEntities;
+using PARR.Domain.Entities.TemplateEntities;
 using PARR.Domain.Entities.Unit;
 using PARR.Domain.Enums;
 using PARR.Domain.Settings;
@@ -18,34 +19,13 @@ namespace PARR.DAL.Context
     {
         public DataContext(DbContextOptions<DataContext> options) : base(options) { }
 
-        //public DbSet<Host> Hosts { get; set; }
-        //public DbSet<WorkGroup> WorkGroups { get; set; }
-        //public DbSet<AppInWorkInWorkGroup> AppInWorkInWorkGroups { get; set; }
-        //public DbSet<EkStatus> EkStatuses { get; set; }
-        //public DbSet<ResponseArea> ResponseAreas { get; set; }
-        //public DbSet<Application> Applications { get; set; }
-        //public DbSet<ApplicationType> ApplicationTypes { get; set; }
-        //public DbSet<ApplicationInHost> ApplicationsInHosts { get; set; }
-
-        public DbSet<Template> Templates { get; set; }
-        public DbSet<TemplateHistory> TemplateHistories { get; set; }
-        public DbSet<TemplateStatusType> TemplateStatusTypes { get; set; }
-        public DbSet<Domain.Entities.TaskStatus> TaskStatuses { get; set; }
-        public DbSet<RobotStatus> RobotStatuses { get; set; }
-
         public DbSet<Process> Processes { get; set; }
         public DbSet<Subprocess> Subprocesses { get; set; }
         public DbSet<Tnk> Tnks { get; set; }
 
-        //public DbSet<ApplicationsInWork> ApplicationsInWorks { get; set; }
-
         public DbSet<Setting> Setting { get; set; }
 
-        public DbSet<RobotHistoryLevel> RobotHistoryLevels { get; set; }
-
-        public DbSet<Robot> Robots { get; set; }
         public DbSet<RobotConfiguration> RobotConfigurations { get; set; }
-        public DbSet<RobotHistory> RobotHistories { get; set; }
 
         #region Schedule
 
@@ -59,6 +39,8 @@ namespace PARR.DAL.Context
         public DbSet<ScheduleExcludeType> ScheduleExcludeTypes { get; set; }
         public DbSet<ScheduleResponseAreaTimeOffset> ScheduleResponseAreaTimeOffsets { get; set; }
 
+        public DbSet<DistributionPeriod> DistributionPeriods { get; set; }
+
         #endregion
 
         public DbSet<AgentHistory> AgentHistories { get; set; }
@@ -73,8 +55,6 @@ namespace PARR.DAL.Context
 
         public DbSet<WeekendDay> WeekendDays { get; set; }
 
-        public DbSet<DistributionPeriod> DistributionPeriods { get; set; }
-
         public DbSet<ParrComponent> ParrComponents { get; set; }
 
         #region Units
@@ -142,11 +122,25 @@ namespace PARR.DAL.Context
 
         #region Robot
 
+        public DbSet<RobotHistory> RobotHistories { get; set; }
+        public DbSet<RobotHistoryLevel> RobotHistoryLevels { get; set; }
+        public DbSet<Robot> Robots { get; set; }
+        public DbSet<Domain.Entities.RobotEntities.TaskStatus> TaskStatuses { get; set; }
+        public DbSet<RobotStatus> RobotStatuses { get; set; }
         public DbSet<RobotSnapshot> RobotSnapshots { get; set; }
         public DbSet<RobotConfigurationSnapshot> RobotConfigurationSnapshots { get; set; }
 
         #endregion
 
+        #region Template
+
+        public DbSet<Template> Templates { get; set; }
+        public DbSet<TemplateHistory> TemplateHistories { get; set; }
+        public DbSet<TemplateStatusType> TemplateStatusTypes { get; set; }
+        public DbSet<TemplateRenamePending> TemplateRenamePendings { get; set; }
+
+        #endregion
+
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
@@ -203,7 +197,7 @@ namespace PARR.DAL.Context
             #endregion
 
             #region TaskStatus
-            modelBuilder.Entity<Domain.Entities.TaskStatus>(f =>
+            modelBuilder.Entity<Domain.Entities.RobotEntities.TaskStatus>(f =>
             {
                 f.HasData(
 
diff --git a/PARR.DAL/DependencyInjection.cs b/PARR.DAL/DependencyInjection.cs
index 73b5eb42..8a41b0f7 100644
--- a/PARR.DAL/DependencyInjection.cs
+++ b/PARR.DAL/DependencyInjection.cs
@@ -39,7 +39,10 @@ namespace PARR.DAL
             services.AddDbContext<DataContext>(opt =>
               opt
                 .EnableSensitiveDataLogging()
-                .UseNpgsql(configuration.GetConnectionString("DefaultConnection"))
+                .UseNpgsql(
+                  configuration.GetConnectionString("DefaultConnection")
+                  //, npgsqlOptions => npgsqlOptions.CommandTimeout(300) // Время в секундах (5 минут)
+                  )
             );
 
 
diff --git a/PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.Designer.cs b/PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.Designer.cs
new file mode 100644
index 00000000..22e97dc1
--- /dev/null
+++ b/PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.Designer.cs
@@ -0,0 +1,4096 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using PARR.DAL.Context;
+
+#nullable disable
+
+namespace PARR.DAL.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    [Migration("20260720233522_tblRobotsUpdateScheme")]
+    partial class tblRobotsUpdateScheme
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.16")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("HistoryLevelId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("OrderId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HistoryLevelId");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistoryLevel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AgentHistoryLevels");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Агент начал выполнять задание",
+                            Name = "Start"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Агент завершил выполнение задания",
+                            Name = "End"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Duration")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Type");
+
+                    b.ToTable("DistributionPeriods", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("9bd0bfa8-c316-480b-a001-e09ffe8c9340"),
+                            Duration = "7",
+                            Name = "Еженедельно",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("3a7341a8-085c-461c-babc-6b78dd5d2c67"),
+                            Duration = "30",
+                            Name = "Ежемесячно",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("0ad2dfdb-3833-46d9-979a-c408b7eadc6c"),
+                            Duration = "90",
+                            Name = "Каждые 90 дней",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("31dd3947-8471-4f09-852c-a4f075f1ba7f"),
+                            Duration = "182",
+                            Name = "Каждые пол года",
+                            Type = "Day"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriodType", b =>
+                {
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Type");
+
+                    b.ToTable("DistributionPeriodTypes", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Type = "Day",
+                            Description = "День"
+                        },
+                        new
+                        {
+                            Type = "Month",
+                            Description = "Месяц"
+                        },
+                        new
+                        {
+                            Type = "Year",
+                            Description = "Год"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("IsParentRelationships")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("MaxValueRelationships")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("MinValueRelationships")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ResponseAreaMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateNameMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TnkId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorkGroupMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("TnkId");
+
+                    b.ToTable("Jobs", "job", t =>
+                        {
+                            t.HasComment("Таблица видов работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobAutoControl", b =>
+                {
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("InitUsedScheduleState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("InitUsedTemplateState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsEnable")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("JobId");
+
+                    b.ToTable("AutoControls", "job", t =>
+                        {
+                            t.HasComment("Таблица управления автоконтролем для работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobFieldFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FieldId");
+
+                    b.HasIndex("UnitFilterId");
+
+                    b.ToTable("FieldFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobRelationshipFilter", b =>
+                {
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsFullMatch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsParent")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("UnitFilterId", "FieldId");
+
+                    b.HasIndex("FieldId");
+
+                    b.ToTable("RelationshipFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица фильтров связей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("UnitFilter")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("UnitFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки ЭК, описание полей в АСУ ЕСПП");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.UnitsInTemplate", b =>
+                {
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UnitFieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("TemplateId", "UnitId", "UnitFieldValueId");
+
+                    b.HasIndex("UnitFieldValueId");
+
+                    b.HasIndex("UnitId");
+
+                    b.ToTable("UnitsInTemplates", "job", t =>
+                        {
+                            t.HasComment("Таблица связи ЭК в шаблонах");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AgentName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AgentScript")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AgentTimeOutSec")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FullDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GroupName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("GroupTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GroupingUnitFieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAgent")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAutoDistributionEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("IsGroupByResponsible")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsResponseAreaTimezone")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("ReferenceDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("ScheduleExcludeTypeCalendarId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ScheduleExcludeTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ShortDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Solution")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateDuration")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("UserTimeZoneOffsetMinutes")
+                        .HasColumnType("integer")
+                        .HasComment("Смещение часового пояса пользователя в минутах относительно UTC на момент ReferenceDate");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupTypeId");
+
+                    b.HasIndex("GroupingUnitFieldId");
+
+                    b.HasIndex("ScheduleExcludeTypeCalendarId");
+
+                    b.HasIndex("ScheduleExcludeTypeId");
+
+                    b.ToTable("Groups", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания групп работ, для реализации зонтиков");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", b =>
+                {
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("InitUsedScheduleState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("InitUsedTemplateState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsEnable")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("JobGroupId");
+
+                    b.ToTable("AutoControls", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица управления автоконтролем для группы работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", b =>
+                {
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("DistributionPeriodId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsExcludeWeekends")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsGroupingByWorkGroup")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("GroupId");
+
+                    b.HasIndex("DistributionPeriodId");
+
+                    b.ToTable("GroupDistributionConfigs", "jobGroup", t =>
+                        {
+                            t.HasComment("Настройки автораспределения для группы работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupFieldFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FieldId")
+                        .HasDatabaseName("IX_FieldFilters_FieldId1");
+
+                    b.HasIndex("UnitFilterId")
+                        .HasDatabaseName("IX_FieldFilters_UnitFilterId1");
+
+                    b.ToTable("FieldFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupRelationshipFilter", b =>
+                {
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsFullMatch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsParent")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("UnitFilterId", "FieldId");
+
+                    b.HasIndex("FieldId")
+                        .HasDatabaseName("IX_RelationshipFilters_FieldId1");
+
+                    b.ToTable("RelationshipFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица фильтров связей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsAllowJobUnitFilter")
+                        .HasColumnType("boolean")
+                        .HasComment("Разрешить Job фильтры. Влияет только на интерфейс. Мэтчер собирает все фильтры из группы и работ всегда.");
+
+                    b.Property<bool>("IsJobGroupAutoControl")
+                        .HasColumnType("boolean")
+                        .HasComment("Автоконтролем управляет JobGroup? true - да JobGroup, false - Job. Влияет на интерфейс и на логику работы автоконтроля.");
+
+                    b.Property<bool>("IsRelationshipsAllowed")
+                        .HasColumnType("boolean")
+                        .HasComment("Разрешена настройка кол-ва связей");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GroupTypes", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица типов групп работ");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("4fa62e79-86bb-47c2-be1a-72a716a170fa"),
+                            Code = 0,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Обычный",
+                            IsAllowJobUnitFilter = true,
+                            IsJobGroupAutoControl = false,
+                            IsRelationshipsAllowed = false,
+                            Name = "Simple"
+                        },
+                        new
+                        {
+                            Id = new Guid("6ec58b1a-5c40-47b9-b036-4fa490e8d503"),
+                            Code = 1,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Зонтик",
+                            IsAllowJobUnitFilter = false,
+                            IsJobGroupAutoControl = true,
+                            IsRelationshipsAllowed = true,
+                            Name = "Umbrella"
+                        },
+                        new
+                        {
+                            Id = new Guid("318625e5-f833-436a-99df-2a382a1e71c7"),
+                            Code = 2,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Сгруппированный",
+                            IsAllowJobUnitFilter = false,
+                            IsJobGroupAutoControl = true,
+                            IsRelationshipsAllowed = true,
+                            Name = "Group"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("UnitFilter")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobGroupId");
+
+                    b.ToTable("UnitFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки ЭК, описание полей в АСУ ЕСПП");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpirationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("GenerateDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("NextStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Number")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorkGroup")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NextStatusCode");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.HasIndex("StatusCode");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("Orders");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.OrderStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("OrderStatuses");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 1,
+                            Description = "1-Направлен в группу",
+                            Name = "New"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "2-В работе",
+                            Name = "InWork"
+                        },
+                        new
+                        {
+                            Code = 3,
+                            Description = "3-Приостановлен",
+                            Name = "Stop"
+                        },
+                        new
+                        {
+                            Code = 4,
+                            Description = "4-Выполнен",
+                            Name = "Complete"
+                        },
+                        new
+                        {
+                            Code = 5,
+                            Description = "5-Закрыт",
+                            Name = "Closed"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.ParrComponent", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ParrComponents");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 0,
+                            Description = "API",
+                            Name = "Api"
+                        },
+                        new
+                        {
+                            Id = 1,
+                            Description = "Загрузчик из АИХИТ",
+                            Name = "AihitLoader"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Синхронизатор АИХИТ",
+                            Name = "AihitSyncer"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Загрузчик нарядов из ЕСПП",
+                            Name = "EsppOrderLoader"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Управление нарядами ЕСПП",
+                            Name = "EsppOrderManager"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Синхронизатор расписаний",
+                            Name = "EsppScheduleSync"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Синхронизатор шаблонов",
+                            Name = "EsppTemplateSync"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            Description = "Генератор шаблонов",
+                            Name = "GeneratorTemplates"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            Description = "Авто-контроль РР",
+                            Name = "JobAutoControl"
+                        },
+                        new
+                        {
+                            Id = 9,
+                            Description = "Связывание нарядов ЕСПП с ПАРР (шаблонами, агентами)",
+                            Name = "Master"
+                        },
+                        new
+                        {
+                            Id = 10,
+                            Description = "Рассчет даты следующего срабатывания",
+                            Name = "NextRun"
+                        },
+                        new
+                        {
+                            Id = 11,
+                            Description = "Активатор шаблонов / расписаний",
+                            Name = "TemplateActivator"
+                        },
+                        new
+                        {
+                            Id = 12,
+                            Description = "Автораспределение РР",
+                            Name = "TemplateDistributor"
+                        },
+                        new
+                        {
+                            Id = 13,
+                            Description = "Генератор шаблонов",
+                            Name = "TemplateTaskGenerator"
+                        },
+                        new
+                        {
+                            Id = 14,
+                            Description = "Генератор кэша отчетов workload",
+                            Name = "WorkloadBuilder"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Process", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EsppId")
+                        .IsUnique();
+
+                    b.ToTable("Processes");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptsNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastRobotStatusUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RobotCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RobotStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RobotCode");
+
+                    b.HasIndex("RobotStatusCode");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("TemplateId", "RobotCode")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateId", "RobotStatusCode");
+
+                    b.HasIndex("TemplateId", "TaskStatusCode");
+
+                    b.ToTable("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Robots", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 1,
+                            Description = "Робот по созданию/изменению шаблона наряда ЕСПП",
+                            Name = "TemplateOrder"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "Робот по созданию/изменению расписания шаблона наряда в ЕСПП",
+                            Name = "ScheduleOrder"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("integer")
+                        .HasComment("Количество заданий в этой комбинации статусов");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RobotCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RobotStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RobotStatusCode");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("RobotCode", "DateCreated");
+
+                    b.ToTable("ConfigurationSnapshots", "robot", t =>
+                        {
+                            t.HasComment("Снимки заданий роботам");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int>("HistoryLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("RobotConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RobotId")
+                        .HasColumnType("text")
+                        .HasComment("Идентификатор робота. Форматы: H20-R1-T, H20-R1-S, H20-R1-ET, H20-R1-ES.");
+
+                    b.Property<string>("RobotIp")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RobotMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateCreated");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("HistoryLevel", "DateCreated")
+                        .IsDescending(false, true);
+
+                    b.HasIndex("RobotConfigurationId", "DateCreated");
+
+                    b.ToTable("RobotHistories", "robot");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
+                {
+                    b.Property<int>("Level")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Level"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Level");
+
+                    b.ToTable("RobotHistoryLevels", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Level = 1,
+                            Description = "Робот начал работу ",
+                            Name = "Start"
+                        },
+                        new
+                        {
+                            Level = 5,
+                            Description = "Информация",
+                            Name = "Information"
+                        },
+                        new
+                        {
+                            Level = 10,
+                            Description = "Ошибка",
+                            Name = "Error"
+                        },
+                        new
+                        {
+                            Level = 15,
+                            Description = "Успешно завершил работу",
+                            Name = "Complete"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("character varying(45)")
+                        .HasComment("Текущий IP-адрес сервера");
+
+                    b.Property<int>("MaxRobots")
+                        .HasColumnType("integer")
+                        .HasComment("Максимально разрешенное количество роботов на сервере");
+
+                    b.Property<int>("ScheduleRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по расписаниям");
+
+                    b.Property<int>("TemplateRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по шаблонам");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Ip", "DateCreated");
+
+                    b.ToTable("Snapshots", "robot", t =>
+                        {
+                            t.HasComment("Снимки роботов");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("RobotStatuses", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 11,
+                            Description = "Ожидание, ждет пока робот возьмет в работу.",
+                            Name = "Wait"
+                        },
+                        new
+                        {
+                            Code = 22,
+                            Description = "Робот взял в работу.",
+                            Name = "InProgress"
+                        },
+                        new
+                        {
+                            Code = 33,
+                            Description = "Ошибка отработки роботом. Требует ручного вмешательства.",
+                            Name = "Error"
+                        },
+                        new
+                        {
+                            Code = 44,
+                            Description = "Робот успешно отработал.",
+                            Name = "Complete"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("TaskStatuses", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 10,
+                            Description = "Требуется создание объекта в ЕСПП",
+                            Name = "Creating"
+                        },
+                        new
+                        {
+                            Code = 20,
+                            Description = "Требуется обновление объекта в ЕСПП",
+                            Name = "Updating"
+                        },
+                        new
+                        {
+                            Code = 30,
+                            Description = "Нормальное состояние объекта в ЕСПП и ПАРР. Объект в ПАРР соответствует объекту в ЕСПП",
+                            Name = "Ok"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("c8f2f144-e6c2-45d7-ba66-5e9bbd376376"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Администратор",
+                            Name = "administrator"
+                        },
+                        new
+                        {
+                            Id = new Guid("13bca225-7fa4-42fa-9d80-d2d46de261fe"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Робот ЕСПП",
+                            Name = "espp-robot"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EsppSchTypes", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Через интервал",
+                            Name = "Interval"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "День недели: пнд, вт...",
+                            Name = "DayOfWeek"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Число месяца: 1,2,3,4",
+                            Name = "DayOfMonth"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Каждый: первый, второй, третий, четвертый, последний",
+                            Name = "Order"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Месяц: январь, февраль...",
+                            Name = "Month"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Месяц (родительный падеж): января, февраля...",
+                            Name = "MonthGenitive"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TypeId");
+
+                    b.HasIndex("TypeScheduleId", "TypeId")
+                        .IsUnique();
+
+                    b.ToTable("EsppSchTypeConfigs", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("d2693562-b3eb-41e9-97db-c6b5d2ef1bea"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 1,
+                            TypeScheduleId = 1
+                        },
+                        new
+                        {
+                            Id = new Guid("06b2e7aa-6927-4fbf-99fb-67c92a4fce8a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 2,
+                            TypeScheduleId = 2
+                        },
+                        new
+                        {
+                            Id = new Guid("78079071-ff80-417e-9bb0-d928cec853e7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 3,
+                            TypeScheduleId = 3
+                        },
+                        new
+                        {
+                            Id = new Guid("accb1d46-e1c1-4396-9182-4c0766155921"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 4,
+                            TypeScheduleId = 4
+                        },
+                        new
+                        {
+                            Id = new Guid("162ffe73-2428-4abe-8f83-235c2593664c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 2,
+                            TypeScheduleId = 4
+                        },
+                        new
+                        {
+                            Id = new Guid("8470d1ef-165d-42fc-ab05-8203e4d263cf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 5,
+                            TypeScheduleId = 5
+                        },
+                        new
+                        {
+                            Id = new Guid("006900b5-f65c-413e-bc67-09e6dae60b7c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 3,
+                            TypeScheduleId = 5
+                        },
+                        new
+                        {
+                            Id = new Guid("85635bc8-f17a-46b8-9c15-8615761be3d9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 4,
+                            TypeScheduleId = 6
+                        },
+                        new
+                        {
+                            Id = new Guid("439460c2-deca-4b54-80e7-2f20806696ec"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 2,
+                            TypeScheduleId = 6
+                        },
+                        new
+                        {
+                            Id = new Guid("5c63ad8c-e9b4-43fd-9d24-5c2eed80dadd"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 2,
+                            TypeId = 6,
+                            TypeScheduleId = 6
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EsppSchTypeSchedules", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Регулярно",
+                            Name = "Regularly"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Еженедельно",
+                            Name = "Weekly"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Ежемесячно",
+                            Name = "Monthly"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Ежемесячно-2",
+                            Name = "Monthly2"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Ежегодно",
+                            Name = "Annually"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Ежегодно-2",
+                            Name = "Annually2"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppExportValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TypeId");
+
+                    b.ToTable("EsppSchTypeValues", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("6e3b5dd2-b2f7-40bc-bace-15bfa6bbd4ff"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "01:00:00",
+                            Order = 0,
+                            TypeId = 1,
+                            Value = "Каждый час"
+                        },
+                        new
+                        {
+                            Id = new Guid("4df04834-f14f-43d9-8984-334f080f4107"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "02:00:00",
+                            Order = 1,
+                            TypeId = 1,
+                            Value = "Каждые 2 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("dab6e3f9-2385-4966-b77c-133ad233c592"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "03:00:00",
+                            Order = 2,
+                            TypeId = 1,
+                            Value = "Каждые 3 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("035f485d-8451-47df-bfaa-ba4dd36cf146"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "04:00:00",
+                            Order = 3,
+                            TypeId = 1,
+                            Value = "Каждые 4 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("d627daa7-3eed-4571-acae-ffbb3c5bedb9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "06:00:00",
+                            Order = 4,
+                            TypeId = 1,
+                            Value = "Каждые 6 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("ae0a0015-0f1e-4496-b71e-6244f7e321e7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12:00:00",
+                            Order = 5,
+                            TypeId = 1,
+                            Value = "Каждые 12 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("8df097aa-9860-4a62-9675-a8eecd3f2ce7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1 00:00:00",
+                            Order = 6,
+                            TypeId = 1,
+                            Value = "Ежедневно"
+                        },
+                        new
+                        {
+                            Id = new Guid("dee32e60-c1a1-4206-98bc-aa03deabfdf6"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3 00:00:00",
+                            Order = 7,
+                            TypeId = 1,
+                            Value = "Каждые 72 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("e0465fbf-e3a5-4486-9f53-5bb85c6feeca"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4 00:00:00",
+                            Order = 8,
+                            TypeId = 1,
+                            Value = "Каждые 96 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("4e3f73d1-a0f3-4dd1-bca9-68ada0dd5ce2"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "14 00:00:00",
+                            Order = 9,
+                            TypeId = 1,
+                            Value = "Каждые 2 недели"
+                        },
+                        new
+                        {
+                            Id = new Guid("55833417-6a24-42f6-bcc2-5d032f883202"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "60 00:00:00",
+                            Order = 10,
+                            TypeId = 1,
+                            Value = "Каждые 60 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("7fefa052-29db-4ce5-9c57-2fd9ff855f21"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "80 00:00:00",
+                            Order = 11,
+                            TypeId = 1,
+                            Value = "Каждые 80 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("b0ca99f9-5ee0-45b3-bb80-948f82b1fcb1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "90 00:00:00",
+                            Order = 12,
+                            TypeId = 1,
+                            Value = "Каждые 90 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("086f7a37-9848-423a-a3cc-36dbb5ad43e3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "182 00:00:00",
+                            Order = 13,
+                            TypeId = 1,
+                            Value = "Каждые полгода"
+                        },
+                        new
+                        {
+                            Id = new Guid("f2da9e02-d619-4517-a598-374880a8c8e8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "540 00:00:00",
+                            Order = 14,
+                            TypeId = 1,
+                            Value = "Каждые 1,5 года"
+                        },
+                        new
+                        {
+                            Id = new Guid("f38d7d30-8923-4ea0-aa7c-5b251e19ab61"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1095 00:00:00",
+                            Order = 15,
+                            TypeId = 1,
+                            Value = "Каждые 3 года"
+                        },
+                        new
+                        {
+                            Id = new Guid("b7303461-9a30-43fa-8e55-305aa13f186f"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 2,
+                            Value = "Понедельник"
+                        },
+                        new
+                        {
+                            Id = new Guid("e951135e-71f2-4262-9342-df4d5315ab6c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 2,
+                            Value = "Вторник"
+                        },
+                        new
+                        {
+                            Id = new Guid("c34d5375-70e7-4632-b3af-30e279a0621a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 2,
+                            Value = "Среда"
+                        },
+                        new
+                        {
+                            Id = new Guid("ec9540df-c2de-4bda-a063-34d02d4b6e03"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 2,
+                            Value = "Четверг"
+                        },
+                        new
+                        {
+                            Id = new Guid("2ed85534-4684-4eb2-9ccb-e264d212c945"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 2,
+                            Value = "Пятница"
+                        },
+                        new
+                        {
+                            Id = new Guid("a6804315-96ef-484e-82ee-c5795694468b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 2,
+                            Value = "Суббота"
+                        },
+                        new
+                        {
+                            Id = new Guid("eb71e699-937f-4894-9688-f7a7f95e5e58"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 2,
+                            Value = "Воскресенье"
+                        },
+                        new
+                        {
+                            Id = new Guid("e86adbfb-3345-4e0c-aa3b-b4418f9cfe88"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 3,
+                            Value = "1"
+                        },
+                        new
+                        {
+                            Id = new Guid("5b4d7ca6-31e7-475b-b7c8-13c6680c3dc3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 3,
+                            Value = "2"
+                        },
+                        new
+                        {
+                            Id = new Guid("0da03db0-9404-425d-bea1-5da0c9b60b59"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 3,
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Id = new Guid("199474c8-0a77-47e5-aab8-ba33c216cc9e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 3,
+                            Value = "4"
+                        },
+                        new
+                        {
+                            Id = new Guid("e6619da1-f7e8-45b9-bbd3-9c17bec2ccd3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 3,
+                            Value = "5"
+                        },
+                        new
+                        {
+                            Id = new Guid("a8708763-c838-49a5-95fe-bf4f73518d71"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 3,
+                            Value = "6"
+                        },
+                        new
+                        {
+                            Id = new Guid("7ec056aa-820c-4900-96cb-4564d2ea6398"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 3,
+                            Value = "7"
+                        },
+                        new
+                        {
+                            Id = new Guid("554d7d0c-91b1-4b81-b94d-1ee864192962"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 3,
+                            Value = "8"
+                        },
+                        new
+                        {
+                            Id = new Guid("8b7847a4-23de-4199-8aad-3b5c0323b5a2"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 3,
+                            Value = "9"
+                        },
+                        new
+                        {
+                            Id = new Guid("fb7f41ca-950b-4dc1-a0a6-bd9a221ab2ad"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 3,
+                            Value = "10"
+                        },
+                        new
+                        {
+                            Id = new Guid("a28b530f-ea38-4a2c-a16b-0b7fa3770d3c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 3,
+                            Value = "11"
+                        },
+                        new
+                        {
+                            Id = new Guid("7a004a11-32e1-40ae-ab35-0d3dc3a69785"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 3,
+                            Value = "12"
+                        },
+                        new
+                        {
+                            Id = new Guid("e0f2f4d1-4a5e-4997-8336-83c3c35f38df"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "13",
+                            Order = 12,
+                            TypeId = 3,
+                            Value = "13"
+                        },
+                        new
+                        {
+                            Id = new Guid("9c5aaf48-88ec-4c67-b936-2be45550f8bf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "14",
+                            Order = 13,
+                            TypeId = 3,
+                            Value = "14"
+                        },
+                        new
+                        {
+                            Id = new Guid("8dbd680c-ce49-4d2e-8a1a-05619685e240"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "15",
+                            Order = 14,
+                            TypeId = 3,
+                            Value = "15"
+                        },
+                        new
+                        {
+                            Id = new Guid("2f476f70-b1ef-419d-aad5-3911f1e3231f"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "16",
+                            Order = 15,
+                            TypeId = 3,
+                            Value = "16"
+                        },
+                        new
+                        {
+                            Id = new Guid("2c635ce2-fc18-47be-b3e9-98c211abf312"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "17",
+                            Order = 16,
+                            TypeId = 3,
+                            Value = "17"
+                        },
+                        new
+                        {
+                            Id = new Guid("f9d5b03b-624a-4f9f-8da3-1490ea5d2914"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "18",
+                            Order = 17,
+                            TypeId = 3,
+                            Value = "18"
+                        },
+                        new
+                        {
+                            Id = new Guid("4f4b249c-db60-4582-86ed-75cfee4edd0c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "19",
+                            Order = 18,
+                            TypeId = 3,
+                            Value = "19"
+                        },
+                        new
+                        {
+                            Id = new Guid("220a1464-4d39-416c-b4b2-3093eb007298"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "20",
+                            Order = 19,
+                            TypeId = 3,
+                            Value = "20"
+                        },
+                        new
+                        {
+                            Id = new Guid("c887ca60-b05d-4d3c-ad1f-223c879b1a6d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "21",
+                            Order = 20,
+                            TypeId = 3,
+                            Value = "21"
+                        },
+                        new
+                        {
+                            Id = new Guid("2905765d-63fb-41fe-a111-ee2f1d03d62e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "22",
+                            Order = 21,
+                            TypeId = 3,
+                            Value = "22"
+                        },
+                        new
+                        {
+                            Id = new Guid("dbbe704a-8d6d-40e7-bd30-6974035b1fab"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "23",
+                            Order = 22,
+                            TypeId = 3,
+                            Value = "23"
+                        },
+                        new
+                        {
+                            Id = new Guid("cf7b9645-52ed-43a2-8267-267e0aed19b1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "24",
+                            Order = 23,
+                            TypeId = 3,
+                            Value = "24"
+                        },
+                        new
+                        {
+                            Id = new Guid("454788d6-d0ad-4c07-878c-da3fd3cd05e1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "25",
+                            Order = 24,
+                            TypeId = 3,
+                            Value = "25"
+                        },
+                        new
+                        {
+                            Id = new Guid("40d70d73-8582-4be6-a9e6-503b96ae3d49"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "26",
+                            Order = 25,
+                            TypeId = 3,
+                            Value = "26"
+                        },
+                        new
+                        {
+                            Id = new Guid("8f6610dc-ef46-4842-a57e-18d7aaa75931"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "27",
+                            Order = 26,
+                            TypeId = 3,
+                            Value = "27"
+                        },
+                        new
+                        {
+                            Id = new Guid("03858472-d4ce-47fd-9497-8051728766e4"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "28",
+                            Order = 27,
+                            TypeId = 3,
+                            Value = "28"
+                        },
+                        new
+                        {
+                            Id = new Guid("b1018e07-e90e-42ee-b399-19f3d0c14dd6"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "29",
+                            Order = 28,
+                            TypeId = 3,
+                            Value = "29"
+                        },
+                        new
+                        {
+                            Id = new Guid("a1669207-aa31-40fe-98d0-d941008d1655"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "30",
+                            Order = 29,
+                            TypeId = 3,
+                            Value = "30"
+                        },
+                        new
+                        {
+                            Id = new Guid("0936aa99-73e0-43de-b6df-334c1228a226"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "31",
+                            Order = 30,
+                            TypeId = 3,
+                            Value = "31"
+                        },
+                        new
+                        {
+                            Id = new Guid("626ca076-f09e-4a7a-8610-b7de6337b24a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 4,
+                            Value = "Первый"
+                        },
+                        new
+                        {
+                            Id = new Guid("032fbd02-67d0-4b8c-bed0-42629ab7113b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 4,
+                            Value = "Второй"
+                        },
+                        new
+                        {
+                            Id = new Guid("fa8a8f60-e41e-495e-ac86-35174d9976bf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 4,
+                            Value = "Третий"
+                        },
+                        new
+                        {
+                            Id = new Guid("d2f90168-2b49-42f2-820b-79db2c522adf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 4,
+                            Value = "Четвертый"
+                        },
+                        new
+                        {
+                            Id = new Guid("12bb8db2-cf7f-4113-baff-6883770f1ba5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 4,
+                            Value = "Последний"
+                        },
+                        new
+                        {
+                            Id = new Guid("18260e91-3fbe-4401-9edc-78dbc419370e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 5,
+                            Value = "Январь"
+                        },
+                        new
+                        {
+                            Id = new Guid("361526aa-3e1c-452e-bb44-0ade8521830d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 5,
+                            Value = "Февраль"
+                        },
+                        new
+                        {
+                            Id = new Guid("fad4bdb0-6c51-4810-a30b-6d031a0d4c46"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 5,
+                            Value = "Март"
+                        },
+                        new
+                        {
+                            Id = new Guid("06ab835d-3d3e-4057-8422-a553b6b40995"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 5,
+                            Value = "Апрель"
+                        },
+                        new
+                        {
+                            Id = new Guid("83f56b5d-b16b-4aa5-89d7-a253fee4e4ad"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 5,
+                            Value = "Май"
+                        },
+                        new
+                        {
+                            Id = new Guid("e679ec84-a9ee-4bed-a051-2b14edddcb18"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 5,
+                            Value = "Июнь"
+                        },
+                        new
+                        {
+                            Id = new Guid("d439808a-6a10-409b-8809-a755b7cca60b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 5,
+                            Value = "Июль"
+                        },
+                        new
+                        {
+                            Id = new Guid("6e9972c4-6bf7-4fe4-b4ea-bbb333fb69c8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 5,
+                            Value = "Август"
+                        },
+                        new
+                        {
+                            Id = new Guid("0883aac2-9d5b-4098-b672-c684d2a3a0c9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 5,
+                            Value = "Сентябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("5e6592bc-acb2-45a4-979b-fdecf8457453"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 5,
+                            Value = "Октябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("edd7cb49-d6a0-4969-b2d6-1967da69b336"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 5,
+                            Value = "Ноябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("dd695fb2-4ad0-4cda-a4df-e15059c56b24"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 5,
+                            Value = "Декабрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("2f473624-4eb3-49b4-a4b9-cc7fc08a50f5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 6,
+                            Value = "Января"
+                        },
+                        new
+                        {
+                            Id = new Guid("f0003490-a249-44bd-814f-4566999915d8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 6,
+                            Value = "Февраля"
+                        },
+                        new
+                        {
+                            Id = new Guid("f4c3fe38-aeaa-42f7-a9ba-190ea2dfe339"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 6,
+                            Value = "Марта"
+                        },
+                        new
+                        {
+                            Id = new Guid("06a8bd2f-68e1-42f5-961c-ac3b98a2181e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 6,
+                            Value = "Апреля"
+                        },
+                        new
+                        {
+                            Id = new Guid("963b9c41-d607-444a-9fe0-fe429590e326"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 6,
+                            Value = "Мая"
+                        },
+                        new
+                        {
+                            Id = new Guid("ec8554c8-dee4-49a1-b1b7-474ad8ec1473"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 6,
+                            Value = "Июня"
+                        },
+                        new
+                        {
+                            Id = new Guid("e15c7c63-e29f-41a3-9c82-f70eb6c24fde"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 6,
+                            Value = "Июля"
+                        },
+                        new
+                        {
+                            Id = new Guid("0b1f3cea-301a-4d74-9ce1-2cd93b41897d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 6,
+                            Value = "Августа"
+                        },
+                        new
+                        {
+                            Id = new Guid("e2fa3769-f66f-4753-a161-35adad7717a5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 6,
+                            Value = "Сентября"
+                        },
+                        new
+                        {
+                            Id = new Guid("c1de4aca-9f49-48ae-9279-cf9ec4092112"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 6,
+                            Value = "Октября"
+                        },
+                        new
+                        {
+                            Id = new Guid("a74b9ebd-bcd8-4537-b371-194de2fe0a4d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 6,
+                            Value = "Ноября"
+                        },
+                        new
+                        {
+                            Id = new Guid("852a5ebd-4545-494b-bc69-c27409a41adc"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 6,
+                            Value = "Декабря"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchValue", b =>
+                {
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TypeValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TypeConfigId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("JobGroupId", "TypeValueId", "TypeConfigId");
+
+                    b.HasIndex("TypeConfigId");
+
+                    b.HasIndex("TypeValueId");
+
+                    b.ToTable("EsppSchValues", "schedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ExcludeTypes", "schedule", t =>
+                        {
+                            t.HasComment("Расписание регламентной работы - Тип исключения");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("0595b8e0-f322-4661-b5e3-064af8fbe7cd"),
+                            Code = "None",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Нет исключений",
+                            EsppValue = "NONE",
+                            Title = "Нет исключений"
+                        },
+                        new
+                        {
+                            Id = new Guid("2b7a4356-9aaf-4e00-b444-42f0b5010e25"),
+                            Code = "Only",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Выполнить ТОЛЬКО В указанном календаре",
+                            EsppValue = "ONLY",
+                            Title = "Выполнить ТОЛЬКО В указанном календаре"
+                        },
+                        new
+                        {
+                            Id = new Guid("38cd9e64-27c1-4672-a805-2211952a48bd"),
+                            Code = "Except",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Выполнить везде, КРОМЕ указанного календаря",
+                            EsppValue = "EXCEPT",
+                            Title = "Выполнить везде, КРОМЕ указанного календаря"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ExcludeTypeCalendars", "schedule", t =>
+                        {
+                            t.HasComment("Расписание регламентной работы, исключение - Календарь");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("a26edb88-0267-4fbf-b7ec-d172b0a86c9c"),
+                            Code = "24x5",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "24x5",
+                            EsppValue = "24x5",
+                            Title = "24x5"
+                        },
+                        new
+                        {
+                            Id = new Guid("6834f1d5-ac51-43d5-974e-4c759d7bbf9f"),
+                            Code = "24x7",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "24x7",
+                            EsppValue = "24x7",
+                            Title = "24x7"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleResponseAreaTimeOffset", b =>
+                {
+                    b.Property<string>("ResponseArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<TimeSpan>("UtcTimeOffset")
+                        .HasColumnType("interval");
+
+                    b.HasKey("ResponseArea");
+
+                    b.ToTable("ResponseAreaTimeOffsets", "schedule", t =>
+                        {
+                            t.HasComment("Расписание в ЕСПП. Смещение часового пояса относительно МСК для зоны ответственности рабочей группы");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Setting", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("Settings");
+
+                    b.HasData(
+                        new
+                        {
+                            Name = "Initiator",
+                            Description = "Инициатор регламентной работы, указывается при создании шаблона в ЕСПП.",
+                            Value = "АКСЕНОВ АЛЕКСАНДР ЕВГЕНЬЕВИЧ (AKSENOVAE@GVC.OAO.RZD)"
+                        },
+                        new
+                        {
+                            Name = "ClosingCode",
+                            Description = "Код закрытия регламентной работы, указывается при создании шаблона в ЕСПП.",
+                            Value = "выполнен"
+                        },
+                        new
+                        {
+                            Name = "Category",
+                            Description = "Категория создаваемого объекта в ЕСПП",
+                            Value = "регламентная работа"
+                        },
+                        new
+                        {
+                            Name = "TemplatePrefixName",
+                            Description = "Префикс имени шаблона в ЕСПП",
+                            Value = "%PREFIX%-ЭИТИ-ПТК-ПАРР"
+                        },
+                        new
+                        {
+                            Name = "RobotAttemptsNumber",
+                            Description = "Количество попыток выполнения задания роботом",
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Name = "RobotWaitTime",
+                            Description = "Время ожидания выполнения роботом задания",
+                            Value = "00:10:00"
+                        },
+                        new
+                        {
+                            Name = "EsppScheduleTimezone",
+                            Description = "Расписание регламентной работы - В каком часовом поясе",
+                            Value = "MSK"
+                        },
+                        new
+                        {
+                            Name = "ScheduleRepeatRange",
+                            Description = "Расписание регламентной работы - Диапазн повторов",
+                            Value = "Отсутствует дата завершения"
+                        },
+                        new
+                        {
+                            Name = "OrderSearchDeltaDate",
+                            Description = "Промежуток времени для поиска нарядов в ЕСПП",
+                            Value = "01:30:00"
+                        },
+                        new
+                        {
+                            Name = "EsppRobotAccountTimeZoneHour",
+                            Description = "Таймзона УЗ роботов в ЕСПП, в часах (может быть положительная и отрицательная)",
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Name = "WeekendCacheTtl",
+                            Description = "Время хранения в кэше данных о выходных и рабочих днях",
+                            Value = "01:00:00"
+                        },
+                        new
+                        {
+                            Name = "TemplateNameConstantParts",
+                            Description = "Список неизменных частей имени шаблона",
+                            Value = "[{\"Name\":\"П-1\",\"Value\":\"ЭИТИ-ПАРР\"}]"
+                        },
+                        new
+                        {
+                            Name = "EsppUnitTag",
+                            Description = "Префикс тега в поле ЭК \"Дополнительная информация\"",
+                            Value = "ПАРР_"
+                        },
+                        new
+                        {
+                            Name = "JobIdForUnusedTemplates",
+                            Description = "Job в который перемещаем ниспользованные шаблоны",
+                            Value = "8f85a91c-a223-4686-bb69-1f0ee73624f2"
+                        },
+                        new
+                        {
+                            Name = "DefaultResponseAreaToTimeOffset",
+                            Description = "Зона ответственности для получения тайм зоны по умолчанию для расписаний",
+                            Value = "17-МСК"
+                        },
+                        new
+                        {
+                            Name = "MinRelationshipsThresholdPct",
+                            Description = "Минимально допустимый процент связей для продолжения синхронизации. Защищает от удаления данных, если передающая система АИХ ИТ передала аномально малый объем связей. 0 — Защита ОТКЛЮЧЕНА, 100 — Строгий режим.",
+                            Value = "97"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ProcessId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EsppId")
+                        .IsUnique();
+
+                    b.HasIndex("ProcessId");
+
+                    b.ToTable("Subprocesses");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskError", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ErrorMessage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("StackTrace")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TaskId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId");
+
+                    b.ToTable("Errors", "task", t =>
+                        {
+                            t.HasComment("Таблица ошибок заданий");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ProcessedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ProgressPercent")
+                        .HasColumnType("integer")
+                        .HasComment("Процент выполнения задачи");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StatusCode");
+
+                    b.HasIndex("TypeCode");
+
+                    b.ToTable("Tasks", "task", t =>
+                        {
+                            t.HasComment("Таблица заданий");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("Statuses", "task", t =>
+                        {
+                            t.HasComment("Таблица статусов заданий");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 0,
+                            Description = "Ожидание",
+                            Name = "Pending"
+                        },
+                        new
+                        {
+                            Code = 1,
+                            Description = "В работе",
+                            Name = "Processing"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "Выполнено успешно",
+                            Name = "Success"
+                        },
+                        new
+                        {
+                            Code = 3,
+                            Description = "Ошибка",
+                            Name = "Failed"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskType", b =>
+                {
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsSingleton")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MaxExecutionTimeMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RetentionDays")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("Types", "task", t =>
+                        {
+                            t.HasComment("Таблица типов заданий");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 0,
+                            Description = "Формирование данных для отчетности - Загруженность",
+                            IsSingleton = true,
+                            MaxExecutionTimeMinutes = 90,
+                            MaxRetries = 2,
+                            Name = "Workload",
+                            RetentionDays = 90
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("Index")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActiveSchedule")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActiveTemplate")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("LastRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("NextRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ScheduleEsppId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.HasIndex("StatusTypeId");
+
+                    b.HasIndex("UnitId");
+
+                    b.HasIndex("Name", "Index")
+                        .IsUnique();
+
+                    b.ToTable("Templates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateAddedToHistory")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActiveSchedule")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActiveTemplate")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LastRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("NextRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("ParentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ScheduleEsppId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusTypeId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("TemplateHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateStatusType", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TemplateStatusTypes", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 0,
+                            Description = "В работе",
+                            Name = "Used"
+                        },
+                        new
+                        {
+                            Id = 1,
+                            Description = "Не используется",
+                            Name = "Unused"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Обновляется",
+                            Name = "Updating"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Ошибка",
+                            Name = "Error"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("SubprocessId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubprocessId");
+
+                    b.ToTable("Tnks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.Unit", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastLogon")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Units", "unit", t =>
+                        {
+                            t.HasComment("Таблица с ЭК");
+
+                            t.HasCheckConstraint("CK_Units_Name_Upper", "\"Name\" = UPPER(\"Name\") AND \"Name\" IS NOT NULL AND LENGTH(\"Name\")>0");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitField", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AihitName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Code")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppName")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("IsMultipleValue")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AihitName");
+
+                    b.HasIndex("EsppName");
+
+                    b.ToTable("Fields", "unit", t =>
+                        {
+                            t.HasComment("Справочник полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldInUnitFieldValue", b =>
+                {
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("FieldId", "FieldValueId");
+
+                    b.HasIndex("FieldValueId");
+
+                    b.ToTable("FieldInFieldValues", "unit", t =>
+                        {
+                            t.HasComment("Значения полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Value")
+                        .IsUnique();
+
+                    b.ToTable("FieldValues", "unit", t =>
+                        {
+                            t.HasComment("Значения полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInUnit", b =>
+                {
+                    b.Property<Guid>("ParentUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChildUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateSynced")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ParentUnitId", "ChildUnitId");
+
+                    b.HasIndex("ChildUnitId");
+
+                    b.ToTable("UnitInUnits", "unit", t =>
+                        {
+                            t.HasComment("Таблица связей иерархии между ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInValue", b =>
+                {
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UnitId", "FieldId", "ValueId");
+
+                    b.HasIndex("ValueId");
+
+                    b.HasIndex("FieldId", "UnitId");
+
+                    b.HasIndex("FieldId", "ValueId");
+
+                    b.HasIndex("UnitId", "FieldId");
+
+                    b.ToTable("UnitInValues", "unit", t =>
+                        {
+                            t.HasComment("Таблица связи ЭК с полями и со значениями");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitKiiUnit", b =>
+                {
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UnitId");
+
+                    b.ToTable("KiiUnits", "unit", t =>
+                        {
+                            t.HasComment("Таблица - Список ЭК КИИ, которые учавствуют в групповых работах. Создавалась как временная");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", b =>
+                {
+                    b.Property<Guid>("FieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("FieldValueId");
+
+                    b.ToTable("RegionalEkPtkGroups", "unit", t =>
+                        {
+                            t.HasComment("Таблица - региональные группы ПТК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("LastLogon")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Ip")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.UsersInRole", b =>
+                {
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("RoleId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UsersInRoles");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.WeekendDay", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date")
+                        .IsUnique();
+
+                    b.ToTable("WeekendDays", "schedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.AgentHistoryLevel", "AgentHistoryLevel")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("HistoryLevelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Order", "Order")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("OrderId");
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AgentHistoryLevel");
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.DistributionPeriodType", "DistributionPeriodType")
+                        .WithMany("Periods")
+                        .HasForeignKey("Type")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DistributionPeriodType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "Group")
+                        .WithMany("Jobs")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Tnk", "Tnk")
+                        .WithMany("Jobs")
+                        .HasForeignKey("TnkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+
+                    b.Navigation("Tnk");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobAutoControl", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithOne("AutoControl")
+                        .HasForeignKey("PARR.Domain.Entities.JobEntities.JobAutoControl", "JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobFieldFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobFieldFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobEntities.JobUnitFilter", "UnitFilter")
+                        .WithMany("FieldFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobRelationshipFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobEntities.JobUnitFilter", "UnitFilter")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithMany("UnitFilters")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.UnitsInTemplate", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("UnitsInTemplate")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "UnitFieldValue")
+                        .WithMany("UnitsInTemplates")
+                        .HasForeignKey("UnitFieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("TemplatesInUnit")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Unit");
+
+                    b.Navigation("UnitFieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupType", "GroupType")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("GroupTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "GroupingUnitField")
+                        .WithMany("JobGroupWithGrouping")
+                        .HasForeignKey("GroupingUnitFieldId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", "ScheduleExcludeTypeCalendar")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("ScheduleExcludeTypeCalendarId");
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.ScheduleExcludeType", "ScheduleExcludeType")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("ScheduleExcludeTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GroupType");
+
+                    b.Navigation("GroupingUnitField");
+
+                    b.Navigation("ScheduleExcludeType");
+
+                    b.Navigation("ScheduleExcludeTypeCalendar");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithOne("AutoControl")
+                        .HasForeignKey("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", "JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.DistributionPeriod", "DistributionPeriod")
+                        .WithMany("GroupDistributionConfig")
+                        .HasForeignKey("DistributionPeriodId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "Group")
+                        .WithOne("DistributionConfig")
+                        .HasForeignKey("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", "GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DistributionPeriod");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupFieldFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobGroupFieldFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", "UnitFilter")
+                        .WithMany("FieldFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupRelationshipFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobGroupRelationshipFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", "UnitFilter")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithMany()
+                        .HasForeignKey("JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.OrderStatus", "NextStatus")
+                        .WithMany("OrdersNext")
+                        .HasForeignKey("NextStatusCode");
+
+                    b.HasOne("PARR.Domain.Entities.OrderStatus", "OrderStatus")
+                        .WithMany("Orders")
+                        .HasForeignKey("StatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("Orders")
+                        .HasForeignKey("TemplateId");
+
+                    b.Navigation("NextStatus");
+
+                    b.Navigation("OrderStatus");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("RobotCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("RobotStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Robot");
+
+                    b.Navigation("RobotStatus");
+
+                    b.Navigation("TaskStatus");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("RobotCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("RobotStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Robot");
+
+                    b.Navigation("RobotStatus");
+
+                    b.Navigation("TaskStatus");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", "RobotHistoryLevel")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("HistoryLevel")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotConfiguration", "RobotConfiguration")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("RobotConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "StatusTask")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RobotConfiguration");
+
+                    b.Navigation("RobotHistoryLevel");
+
+                    b.Navigation("StatusTask");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchType", "EsppSchType")
+                        .WithMany("EsppSchTypeConfigs")
+                        .HasForeignKey("TypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", "EsppSchTypeSchedule")
+                        .WithMany("EsppSchTypeConfigs")
+                        .HasForeignKey("TypeScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchType");
+
+                    b.Navigation("EsppSchTypeSchedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchType", "EsppSchType")
+                        .WithMany("EsppSchTypeValues")
+                        .HasForeignKey("TypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", "EsppSchTypeConfig")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("TypeConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeValue", "EsppSchTypeValue")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("TypeValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchTypeConfig");
+
+                    b.Navigation("EsppSchTypeValue");
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Process", "Process")
+                        .WithMany("Subprocesses")
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Process");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskError", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskItem", "TaskItem")
+                        .WithMany("TaskErrors")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TaskItem");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskStatus", "TaskStatus")
+                        .WithMany("Tasks")
+                        .HasForeignKey("StatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskType", "TaskType")
+                        .WithMany("Tasks")
+                        .HasForeignKey("TypeCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TaskStatus");
+
+                    b.Navigation("TaskType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithMany("Templates")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.TemplateStatusType", "StatusType")
+                        .WithMany("Templates")
+                        .HasForeignKey("StatusTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("Templates")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+
+                    b.Navigation("StatusType");
+
+                    b.Navigation("Unit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("TemplateHistories")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Subprocess", "Subprocess")
+                        .WithMany("Tnks")
+                        .HasForeignKey("SubprocessId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Subprocess");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldInUnitFieldValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "Field")
+                        .WithMany("UnitFieldValues")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "FieldValue")
+                        .WithMany("FieldValues")
+                        .HasForeignKey("FieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Field");
+
+                    b.Navigation("FieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInUnit", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "ChildUnit")
+                        .WithMany("ParentUnits")
+                        .HasForeignKey("ChildUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "ParentUnit")
+                        .WithMany("ChildUnits")
+                        .HasForeignKey("ParentUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildUnit");
+
+                    b.Navigation("ParentUnit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "Field")
+                        .WithMany("UnitInValues")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("UnitValues")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "Value")
+                        .WithMany("UnitInValues")
+                        .HasForeignKey("ValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Field");
+
+                    b.Navigation("Unit");
+
+                    b.Navigation("Value");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitKiiUnit", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithOne("UnitKii")
+                        .HasForeignKey("PARR.Domain.Entities.Unit.UnitKiiUnit", "UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Unit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "FieldValue")
+                        .WithOne("RegionalEkPtkGroup")
+                        .HasForeignKey("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", "FieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.UsersInRole", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Role", "Role")
+                        .WithMany("Users")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.User", "User")
+                        .WithMany("Roles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistoryLevel", b =>
+                {
+                    b.Navigation("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.Navigation("GroupDistributionConfig");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriodType", b =>
+                {
+                    b.Navigation("Periods");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.Navigation("AutoControl");
+
+                    b.Navigation("Templates");
+
+                    b.Navigation("UnitFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.Navigation("FieldFilters");
+
+                    b.Navigation("RelationshipFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.Navigation("AutoControl");
+
+                    b.Navigation("DistributionConfig");
+
+                    b.Navigation("EsppSchValues");
+
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupType", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.Navigation("FieldFilters");
+
+                    b.Navigation("RelationshipFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.Navigation("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.OrderStatus", b =>
+                {
+                    b.Navigation("Orders");
+
+                    b.Navigation("OrdersNext");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Process", b =>
+                {
+                    b.Navigation("Subprocesses");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
+                {
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
+                {
+                    b.Navigation("Users");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchType", b =>
+                {
+                    b.Navigation("EsppSchTypeConfigs");
+
+                    b.Navigation("EsppSchTypeValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.Navigation("EsppSchValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", b =>
+                {
+                    b.Navigation("EsppSchTypeConfigs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.Navigation("EsppSchValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeType", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.Navigation("Tnks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.Navigation("TaskErrors");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskStatus", b =>
+                {
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskType", b =>
+                {
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.Navigation("AgentHistories");
+
+                    b.Navigation("Orders");
+
+                    b.Navigation("RobotConfigurations");
+
+                    b.Navigation("TemplateHistories");
+
+                    b.Navigation("UnitsInTemplate");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateStatusType", b =>
+                {
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.Unit", b =>
+                {
+                    b.Navigation("ChildUnits");
+
+                    b.Navigation("ParentUnits");
+
+                    b.Navigation("Templates");
+
+                    b.Navigation("TemplatesInUnit");
+
+                    b.Navigation("UnitKii");
+
+                    b.Navigation("UnitValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitField", b =>
+                {
+                    b.Navigation("JobFieldFilters");
+
+                    b.Navigation("JobGroupFieldFilters");
+
+                    b.Navigation("JobGroupRelationshipFilters");
+
+                    b.Navigation("JobGroupWithGrouping");
+
+                    b.Navigation("RelationshipFilters");
+
+                    b.Navigation("UnitFieldValues");
+
+                    b.Navigation("UnitInValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldValue", b =>
+                {
+                    b.Navigation("FieldValues");
+
+                    b.Navigation("RegionalEkPtkGroup");
+
+                    b.Navigation("UnitInValues");
+
+                    b.Navigation("UnitsInTemplates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.User", b =>
+                {
+                    b.Navigation("Roles");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.cs b/PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.cs
new file mode 100644
index 00000000..37cf8507
--- /dev/null
+++ b/PARR.DAL/Migrations/20260720233522_tblRobotsUpdateScheme.cs
@@ -0,0 +1,68 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PARR.DAL.Migrations
+{
+    /// <inheritdoc />
+    public partial class tblRobotsUpdateScheme : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameTable(
+                name: "TaskStatuses",
+                newName: "TaskStatuses",
+                newSchema: "robot");
+
+            migrationBuilder.RenameTable(
+                name: "RobotStatuses",
+                newName: "RobotStatuses",
+                newSchema: "robot");
+
+            migrationBuilder.RenameTable(
+                name: "Robots",
+                newName: "Robots",
+                newSchema: "robot");
+
+            migrationBuilder.RenameTable(
+                name: "RobotHistoryLevels",
+                newName: "RobotHistoryLevels",
+                newSchema: "robot");
+
+            migrationBuilder.RenameTable(
+                name: "RobotHistories",
+                newName: "RobotHistories",
+                newSchema: "robot");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameTable(
+                name: "TaskStatuses",
+                schema: "robot",
+                newName: "TaskStatuses");
+
+            migrationBuilder.RenameTable(
+                name: "RobotStatuses",
+                schema: "robot",
+                newName: "RobotStatuses");
+
+            migrationBuilder.RenameTable(
+                name: "Robots",
+                schema: "robot",
+                newName: "Robots");
+
+            migrationBuilder.RenameTable(
+                name: "RobotHistoryLevels",
+                schema: "robot",
+                newName: "RobotHistoryLevels");
+
+            migrationBuilder.RenameTable(
+                name: "RobotHistories",
+                schema: "robot",
+                newName: "RobotHistories");
+        }
+    }
+}
diff --git a/PARR.DAL/Migrations/20260720233632_tblRobotsRename.Designer.cs b/PARR.DAL/Migrations/20260720233632_tblRobotsRename.Designer.cs
new file mode 100644
index 00000000..18b095d0
--- /dev/null
+++ b/PARR.DAL/Migrations/20260720233632_tblRobotsRename.Designer.cs
@@ -0,0 +1,4096 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using PARR.DAL.Context;
+
+#nullable disable
+
+namespace PARR.DAL.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    [Migration("20260720233632_tblRobotsRename")]
+    partial class tblRobotsRename
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.16")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("HistoryLevelId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("OrderId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HistoryLevelId");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistoryLevel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AgentHistoryLevels");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Агент начал выполнять задание",
+                            Name = "Start"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Агент завершил выполнение задания",
+                            Name = "End"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Duration")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Type");
+
+                    b.ToTable("DistributionPeriods", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("9bd0bfa8-c316-480b-a001-e09ffe8c9340"),
+                            Duration = "7",
+                            Name = "Еженедельно",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("3a7341a8-085c-461c-babc-6b78dd5d2c67"),
+                            Duration = "30",
+                            Name = "Ежемесячно",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("0ad2dfdb-3833-46d9-979a-c408b7eadc6c"),
+                            Duration = "90",
+                            Name = "Каждые 90 дней",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("31dd3947-8471-4f09-852c-a4f075f1ba7f"),
+                            Duration = "182",
+                            Name = "Каждые пол года",
+                            Type = "Day"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriodType", b =>
+                {
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Type");
+
+                    b.ToTable("DistributionPeriodTypes", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Type = "Day",
+                            Description = "День"
+                        },
+                        new
+                        {
+                            Type = "Month",
+                            Description = "Месяц"
+                        },
+                        new
+                        {
+                            Type = "Year",
+                            Description = "Год"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("IsParentRelationships")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("MaxValueRelationships")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("MinValueRelationships")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ResponseAreaMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateNameMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TnkId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorkGroupMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("TnkId");
+
+                    b.ToTable("Jobs", "job", t =>
+                        {
+                            t.HasComment("Таблица видов работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobAutoControl", b =>
+                {
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("InitUsedScheduleState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("InitUsedTemplateState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsEnable")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("JobId");
+
+                    b.ToTable("AutoControls", "job", t =>
+                        {
+                            t.HasComment("Таблица управления автоконтролем для работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobFieldFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FieldId");
+
+                    b.HasIndex("UnitFilterId");
+
+                    b.ToTable("FieldFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobRelationshipFilter", b =>
+                {
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsFullMatch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsParent")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("UnitFilterId", "FieldId");
+
+                    b.HasIndex("FieldId");
+
+                    b.ToTable("RelationshipFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица фильтров связей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("UnitFilter")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("UnitFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки ЭК, описание полей в АСУ ЕСПП");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.UnitsInTemplate", b =>
+                {
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UnitFieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("TemplateId", "UnitId", "UnitFieldValueId");
+
+                    b.HasIndex("UnitFieldValueId");
+
+                    b.HasIndex("UnitId");
+
+                    b.ToTable("UnitsInTemplates", "job", t =>
+                        {
+                            t.HasComment("Таблица связи ЭК в шаблонах");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AgentName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AgentScript")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AgentTimeOutSec")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FullDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GroupName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("GroupTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GroupingUnitFieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAgent")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAutoDistributionEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("IsGroupByResponsible")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsResponseAreaTimezone")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("ReferenceDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("ScheduleExcludeTypeCalendarId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ScheduleExcludeTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ShortDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Solution")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateDuration")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("UserTimeZoneOffsetMinutes")
+                        .HasColumnType("integer")
+                        .HasComment("Смещение часового пояса пользователя в минутах относительно UTC на момент ReferenceDate");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupTypeId");
+
+                    b.HasIndex("GroupingUnitFieldId");
+
+                    b.HasIndex("ScheduleExcludeTypeCalendarId");
+
+                    b.HasIndex("ScheduleExcludeTypeId");
+
+                    b.ToTable("Groups", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания групп работ, для реализации зонтиков");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", b =>
+                {
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("InitUsedScheduleState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("InitUsedTemplateState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsEnable")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("JobGroupId");
+
+                    b.ToTable("AutoControls", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица управления автоконтролем для группы работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", b =>
+                {
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("DistributionPeriodId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsExcludeWeekends")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsGroupingByWorkGroup")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("GroupId");
+
+                    b.HasIndex("DistributionPeriodId");
+
+                    b.ToTable("GroupDistributionConfigs", "jobGroup", t =>
+                        {
+                            t.HasComment("Настройки автораспределения для группы работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupFieldFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FieldId")
+                        .HasDatabaseName("IX_FieldFilters_FieldId1");
+
+                    b.HasIndex("UnitFilterId")
+                        .HasDatabaseName("IX_FieldFilters_UnitFilterId1");
+
+                    b.ToTable("FieldFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupRelationshipFilter", b =>
+                {
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsFullMatch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsParent")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("UnitFilterId", "FieldId");
+
+                    b.HasIndex("FieldId")
+                        .HasDatabaseName("IX_RelationshipFilters_FieldId1");
+
+                    b.ToTable("RelationshipFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица фильтров связей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsAllowJobUnitFilter")
+                        .HasColumnType("boolean")
+                        .HasComment("Разрешить Job фильтры. Влияет только на интерфейс. Мэтчер собирает все фильтры из группы и работ всегда.");
+
+                    b.Property<bool>("IsJobGroupAutoControl")
+                        .HasColumnType("boolean")
+                        .HasComment("Автоконтролем управляет JobGroup? true - да JobGroup, false - Job. Влияет на интерфейс и на логику работы автоконтроля.");
+
+                    b.Property<bool>("IsRelationshipsAllowed")
+                        .HasColumnType("boolean")
+                        .HasComment("Разрешена настройка кол-ва связей");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GroupTypes", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица типов групп работ");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("4fa62e79-86bb-47c2-be1a-72a716a170fa"),
+                            Code = 0,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Обычный",
+                            IsAllowJobUnitFilter = true,
+                            IsJobGroupAutoControl = false,
+                            IsRelationshipsAllowed = false,
+                            Name = "Simple"
+                        },
+                        new
+                        {
+                            Id = new Guid("6ec58b1a-5c40-47b9-b036-4fa490e8d503"),
+                            Code = 1,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Зонтик",
+                            IsAllowJobUnitFilter = false,
+                            IsJobGroupAutoControl = true,
+                            IsRelationshipsAllowed = true,
+                            Name = "Umbrella"
+                        },
+                        new
+                        {
+                            Id = new Guid("318625e5-f833-436a-99df-2a382a1e71c7"),
+                            Code = 2,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Сгруппированный",
+                            IsAllowJobUnitFilter = false,
+                            IsJobGroupAutoControl = true,
+                            IsRelationshipsAllowed = true,
+                            Name = "Group"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("UnitFilter")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobGroupId");
+
+                    b.ToTable("UnitFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки ЭК, описание полей в АСУ ЕСПП");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpirationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("GenerateDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("NextStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Number")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorkGroup")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NextStatusCode");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.HasIndex("StatusCode");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("Orders");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.OrderStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("OrderStatuses");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 1,
+                            Description = "1-Направлен в группу",
+                            Name = "New"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "2-В работе",
+                            Name = "InWork"
+                        },
+                        new
+                        {
+                            Code = 3,
+                            Description = "3-Приостановлен",
+                            Name = "Stop"
+                        },
+                        new
+                        {
+                            Code = 4,
+                            Description = "4-Выполнен",
+                            Name = "Complete"
+                        },
+                        new
+                        {
+                            Code = 5,
+                            Description = "5-Закрыт",
+                            Name = "Closed"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.ParrComponent", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ParrComponents");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 0,
+                            Description = "API",
+                            Name = "Api"
+                        },
+                        new
+                        {
+                            Id = 1,
+                            Description = "Загрузчик из АИХИТ",
+                            Name = "AihitLoader"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Синхронизатор АИХИТ",
+                            Name = "AihitSyncer"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Загрузчик нарядов из ЕСПП",
+                            Name = "EsppOrderLoader"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Управление нарядами ЕСПП",
+                            Name = "EsppOrderManager"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Синхронизатор расписаний",
+                            Name = "EsppScheduleSync"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Синхронизатор шаблонов",
+                            Name = "EsppTemplateSync"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            Description = "Генератор шаблонов",
+                            Name = "GeneratorTemplates"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            Description = "Авто-контроль РР",
+                            Name = "JobAutoControl"
+                        },
+                        new
+                        {
+                            Id = 9,
+                            Description = "Связывание нарядов ЕСПП с ПАРР (шаблонами, агентами)",
+                            Name = "Master"
+                        },
+                        new
+                        {
+                            Id = 10,
+                            Description = "Рассчет даты следующего срабатывания",
+                            Name = "NextRun"
+                        },
+                        new
+                        {
+                            Id = 11,
+                            Description = "Активатор шаблонов / расписаний",
+                            Name = "TemplateActivator"
+                        },
+                        new
+                        {
+                            Id = 12,
+                            Description = "Автораспределение РР",
+                            Name = "TemplateDistributor"
+                        },
+                        new
+                        {
+                            Id = 13,
+                            Description = "Генератор шаблонов",
+                            Name = "TemplateTaskGenerator"
+                        },
+                        new
+                        {
+                            Id = 14,
+                            Description = "Генератор кэша отчетов workload",
+                            Name = "WorkloadBuilder"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Process", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EsppId")
+                        .IsUnique();
+
+                    b.ToTable("Processes");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptsNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastRobotStatusUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RobotCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RobotStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RobotCode");
+
+                    b.HasIndex("RobotStatusCode");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("TemplateId", "RobotCode")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateId", "RobotStatusCode");
+
+                    b.HasIndex("TemplateId", "TaskStatusCode");
+
+                    b.ToTable("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Robots", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 1,
+                            Description = "Робот по созданию/изменению шаблона наряда ЕСПП",
+                            Name = "TemplateOrder"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "Робот по созданию/изменению расписания шаблона наряда в ЕСПП",
+                            Name = "ScheduleOrder"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("integer")
+                        .HasComment("Количество заданий в этой комбинации статусов");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RobotCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RobotStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RobotStatusCode");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("RobotCode", "DateCreated");
+
+                    b.ToTable("ConfigurationSnapshots", "robot", t =>
+                        {
+                            t.HasComment("Снимки заданий роботам");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int>("HistoryLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("RobotConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RobotId")
+                        .HasColumnType("text")
+                        .HasComment("Идентификатор робота. Форматы: H20-R1-T, H20-R1-S, H20-R1-ET, H20-R1-ES.");
+
+                    b.Property<string>("RobotIp")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RobotMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateCreated");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("HistoryLevel", "DateCreated")
+                        .IsDescending(false, true);
+
+                    b.HasIndex("RobotConfigurationId", "DateCreated");
+
+                    b.ToTable("Histories", "robot");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
+                {
+                    b.Property<int>("Level")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Level"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Level");
+
+                    b.ToTable("HistoryLevels", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Level = 1,
+                            Description = "Робот начал работу ",
+                            Name = "Start"
+                        },
+                        new
+                        {
+                            Level = 5,
+                            Description = "Информация",
+                            Name = "Information"
+                        },
+                        new
+                        {
+                            Level = 10,
+                            Description = "Ошибка",
+                            Name = "Error"
+                        },
+                        new
+                        {
+                            Level = 15,
+                            Description = "Успешно завершил работу",
+                            Name = "Complete"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("character varying(45)")
+                        .HasComment("Текущий IP-адрес сервера");
+
+                    b.Property<int>("MaxRobots")
+                        .HasColumnType("integer")
+                        .HasComment("Максимально разрешенное количество роботов на сервере");
+
+                    b.Property<int>("ScheduleRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по расписаниям");
+
+                    b.Property<int>("TemplateRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по шаблонам");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Ip", "DateCreated");
+
+                    b.ToTable("Snapshots", "robot", t =>
+                        {
+                            t.HasComment("Снимки роботов");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("RobotStatuses", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 11,
+                            Description = "Ожидание, ждет пока робот возьмет в работу.",
+                            Name = "Wait"
+                        },
+                        new
+                        {
+                            Code = 22,
+                            Description = "Робот взял в работу.",
+                            Name = "InProgress"
+                        },
+                        new
+                        {
+                            Code = 33,
+                            Description = "Ошибка отработки роботом. Требует ручного вмешательства.",
+                            Name = "Error"
+                        },
+                        new
+                        {
+                            Code = 44,
+                            Description = "Робот успешно отработал.",
+                            Name = "Complete"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("TaskStatuses", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 10,
+                            Description = "Требуется создание объекта в ЕСПП",
+                            Name = "Creating"
+                        },
+                        new
+                        {
+                            Code = 20,
+                            Description = "Требуется обновление объекта в ЕСПП",
+                            Name = "Updating"
+                        },
+                        new
+                        {
+                            Code = 30,
+                            Description = "Нормальное состояние объекта в ЕСПП и ПАРР. Объект в ПАРР соответствует объекту в ЕСПП",
+                            Name = "Ok"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("c8f2f144-e6c2-45d7-ba66-5e9bbd376376"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Администратор",
+                            Name = "administrator"
+                        },
+                        new
+                        {
+                            Id = new Guid("13bca225-7fa4-42fa-9d80-d2d46de261fe"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Робот ЕСПП",
+                            Name = "espp-robot"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EsppSchTypes", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Через интервал",
+                            Name = "Interval"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "День недели: пнд, вт...",
+                            Name = "DayOfWeek"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Число месяца: 1,2,3,4",
+                            Name = "DayOfMonth"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Каждый: первый, второй, третий, четвертый, последний",
+                            Name = "Order"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Месяц: январь, февраль...",
+                            Name = "Month"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Месяц (родительный падеж): января, февраля...",
+                            Name = "MonthGenitive"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TypeId");
+
+                    b.HasIndex("TypeScheduleId", "TypeId")
+                        .IsUnique();
+
+                    b.ToTable("EsppSchTypeConfigs", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("d2693562-b3eb-41e9-97db-c6b5d2ef1bea"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 1,
+                            TypeScheduleId = 1
+                        },
+                        new
+                        {
+                            Id = new Guid("06b2e7aa-6927-4fbf-99fb-67c92a4fce8a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 2,
+                            TypeScheduleId = 2
+                        },
+                        new
+                        {
+                            Id = new Guid("78079071-ff80-417e-9bb0-d928cec853e7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 3,
+                            TypeScheduleId = 3
+                        },
+                        new
+                        {
+                            Id = new Guid("accb1d46-e1c1-4396-9182-4c0766155921"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 4,
+                            TypeScheduleId = 4
+                        },
+                        new
+                        {
+                            Id = new Guid("162ffe73-2428-4abe-8f83-235c2593664c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 2,
+                            TypeScheduleId = 4
+                        },
+                        new
+                        {
+                            Id = new Guid("8470d1ef-165d-42fc-ab05-8203e4d263cf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 5,
+                            TypeScheduleId = 5
+                        },
+                        new
+                        {
+                            Id = new Guid("006900b5-f65c-413e-bc67-09e6dae60b7c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 3,
+                            TypeScheduleId = 5
+                        },
+                        new
+                        {
+                            Id = new Guid("85635bc8-f17a-46b8-9c15-8615761be3d9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 4,
+                            TypeScheduleId = 6
+                        },
+                        new
+                        {
+                            Id = new Guid("439460c2-deca-4b54-80e7-2f20806696ec"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 2,
+                            TypeScheduleId = 6
+                        },
+                        new
+                        {
+                            Id = new Guid("5c63ad8c-e9b4-43fd-9d24-5c2eed80dadd"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 2,
+                            TypeId = 6,
+                            TypeScheduleId = 6
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EsppSchTypeSchedules", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Регулярно",
+                            Name = "Regularly"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Еженедельно",
+                            Name = "Weekly"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Ежемесячно",
+                            Name = "Monthly"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Ежемесячно-2",
+                            Name = "Monthly2"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Ежегодно",
+                            Name = "Annually"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Ежегодно-2",
+                            Name = "Annually2"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppExportValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TypeId");
+
+                    b.ToTable("EsppSchTypeValues", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("6e3b5dd2-b2f7-40bc-bace-15bfa6bbd4ff"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "01:00:00",
+                            Order = 0,
+                            TypeId = 1,
+                            Value = "Каждый час"
+                        },
+                        new
+                        {
+                            Id = new Guid("4df04834-f14f-43d9-8984-334f080f4107"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "02:00:00",
+                            Order = 1,
+                            TypeId = 1,
+                            Value = "Каждые 2 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("dab6e3f9-2385-4966-b77c-133ad233c592"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "03:00:00",
+                            Order = 2,
+                            TypeId = 1,
+                            Value = "Каждые 3 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("035f485d-8451-47df-bfaa-ba4dd36cf146"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "04:00:00",
+                            Order = 3,
+                            TypeId = 1,
+                            Value = "Каждые 4 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("d627daa7-3eed-4571-acae-ffbb3c5bedb9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "06:00:00",
+                            Order = 4,
+                            TypeId = 1,
+                            Value = "Каждые 6 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("ae0a0015-0f1e-4496-b71e-6244f7e321e7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12:00:00",
+                            Order = 5,
+                            TypeId = 1,
+                            Value = "Каждые 12 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("8df097aa-9860-4a62-9675-a8eecd3f2ce7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1 00:00:00",
+                            Order = 6,
+                            TypeId = 1,
+                            Value = "Ежедневно"
+                        },
+                        new
+                        {
+                            Id = new Guid("dee32e60-c1a1-4206-98bc-aa03deabfdf6"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3 00:00:00",
+                            Order = 7,
+                            TypeId = 1,
+                            Value = "Каждые 72 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("e0465fbf-e3a5-4486-9f53-5bb85c6feeca"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4 00:00:00",
+                            Order = 8,
+                            TypeId = 1,
+                            Value = "Каждые 96 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("4e3f73d1-a0f3-4dd1-bca9-68ada0dd5ce2"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "14 00:00:00",
+                            Order = 9,
+                            TypeId = 1,
+                            Value = "Каждые 2 недели"
+                        },
+                        new
+                        {
+                            Id = new Guid("55833417-6a24-42f6-bcc2-5d032f883202"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "60 00:00:00",
+                            Order = 10,
+                            TypeId = 1,
+                            Value = "Каждые 60 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("7fefa052-29db-4ce5-9c57-2fd9ff855f21"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "80 00:00:00",
+                            Order = 11,
+                            TypeId = 1,
+                            Value = "Каждые 80 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("b0ca99f9-5ee0-45b3-bb80-948f82b1fcb1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "90 00:00:00",
+                            Order = 12,
+                            TypeId = 1,
+                            Value = "Каждые 90 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("086f7a37-9848-423a-a3cc-36dbb5ad43e3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "182 00:00:00",
+                            Order = 13,
+                            TypeId = 1,
+                            Value = "Каждые полгода"
+                        },
+                        new
+                        {
+                            Id = new Guid("f2da9e02-d619-4517-a598-374880a8c8e8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "540 00:00:00",
+                            Order = 14,
+                            TypeId = 1,
+                            Value = "Каждые 1,5 года"
+                        },
+                        new
+                        {
+                            Id = new Guid("f38d7d30-8923-4ea0-aa7c-5b251e19ab61"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1095 00:00:00",
+                            Order = 15,
+                            TypeId = 1,
+                            Value = "Каждые 3 года"
+                        },
+                        new
+                        {
+                            Id = new Guid("b7303461-9a30-43fa-8e55-305aa13f186f"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 2,
+                            Value = "Понедельник"
+                        },
+                        new
+                        {
+                            Id = new Guid("e951135e-71f2-4262-9342-df4d5315ab6c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 2,
+                            Value = "Вторник"
+                        },
+                        new
+                        {
+                            Id = new Guid("c34d5375-70e7-4632-b3af-30e279a0621a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 2,
+                            Value = "Среда"
+                        },
+                        new
+                        {
+                            Id = new Guid("ec9540df-c2de-4bda-a063-34d02d4b6e03"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 2,
+                            Value = "Четверг"
+                        },
+                        new
+                        {
+                            Id = new Guid("2ed85534-4684-4eb2-9ccb-e264d212c945"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 2,
+                            Value = "Пятница"
+                        },
+                        new
+                        {
+                            Id = new Guid("a6804315-96ef-484e-82ee-c5795694468b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 2,
+                            Value = "Суббота"
+                        },
+                        new
+                        {
+                            Id = new Guid("eb71e699-937f-4894-9688-f7a7f95e5e58"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 2,
+                            Value = "Воскресенье"
+                        },
+                        new
+                        {
+                            Id = new Guid("e86adbfb-3345-4e0c-aa3b-b4418f9cfe88"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 3,
+                            Value = "1"
+                        },
+                        new
+                        {
+                            Id = new Guid("5b4d7ca6-31e7-475b-b7c8-13c6680c3dc3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 3,
+                            Value = "2"
+                        },
+                        new
+                        {
+                            Id = new Guid("0da03db0-9404-425d-bea1-5da0c9b60b59"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 3,
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Id = new Guid("199474c8-0a77-47e5-aab8-ba33c216cc9e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 3,
+                            Value = "4"
+                        },
+                        new
+                        {
+                            Id = new Guid("e6619da1-f7e8-45b9-bbd3-9c17bec2ccd3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 3,
+                            Value = "5"
+                        },
+                        new
+                        {
+                            Id = new Guid("a8708763-c838-49a5-95fe-bf4f73518d71"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 3,
+                            Value = "6"
+                        },
+                        new
+                        {
+                            Id = new Guid("7ec056aa-820c-4900-96cb-4564d2ea6398"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 3,
+                            Value = "7"
+                        },
+                        new
+                        {
+                            Id = new Guid("554d7d0c-91b1-4b81-b94d-1ee864192962"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 3,
+                            Value = "8"
+                        },
+                        new
+                        {
+                            Id = new Guid("8b7847a4-23de-4199-8aad-3b5c0323b5a2"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 3,
+                            Value = "9"
+                        },
+                        new
+                        {
+                            Id = new Guid("fb7f41ca-950b-4dc1-a0a6-bd9a221ab2ad"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 3,
+                            Value = "10"
+                        },
+                        new
+                        {
+                            Id = new Guid("a28b530f-ea38-4a2c-a16b-0b7fa3770d3c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 3,
+                            Value = "11"
+                        },
+                        new
+                        {
+                            Id = new Guid("7a004a11-32e1-40ae-ab35-0d3dc3a69785"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 3,
+                            Value = "12"
+                        },
+                        new
+                        {
+                            Id = new Guid("e0f2f4d1-4a5e-4997-8336-83c3c35f38df"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "13",
+                            Order = 12,
+                            TypeId = 3,
+                            Value = "13"
+                        },
+                        new
+                        {
+                            Id = new Guid("9c5aaf48-88ec-4c67-b936-2be45550f8bf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "14",
+                            Order = 13,
+                            TypeId = 3,
+                            Value = "14"
+                        },
+                        new
+                        {
+                            Id = new Guid("8dbd680c-ce49-4d2e-8a1a-05619685e240"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "15",
+                            Order = 14,
+                            TypeId = 3,
+                            Value = "15"
+                        },
+                        new
+                        {
+                            Id = new Guid("2f476f70-b1ef-419d-aad5-3911f1e3231f"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "16",
+                            Order = 15,
+                            TypeId = 3,
+                            Value = "16"
+                        },
+                        new
+                        {
+                            Id = new Guid("2c635ce2-fc18-47be-b3e9-98c211abf312"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "17",
+                            Order = 16,
+                            TypeId = 3,
+                            Value = "17"
+                        },
+                        new
+                        {
+                            Id = new Guid("f9d5b03b-624a-4f9f-8da3-1490ea5d2914"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "18",
+                            Order = 17,
+                            TypeId = 3,
+                            Value = "18"
+                        },
+                        new
+                        {
+                            Id = new Guid("4f4b249c-db60-4582-86ed-75cfee4edd0c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "19",
+                            Order = 18,
+                            TypeId = 3,
+                            Value = "19"
+                        },
+                        new
+                        {
+                            Id = new Guid("220a1464-4d39-416c-b4b2-3093eb007298"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "20",
+                            Order = 19,
+                            TypeId = 3,
+                            Value = "20"
+                        },
+                        new
+                        {
+                            Id = new Guid("c887ca60-b05d-4d3c-ad1f-223c879b1a6d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "21",
+                            Order = 20,
+                            TypeId = 3,
+                            Value = "21"
+                        },
+                        new
+                        {
+                            Id = new Guid("2905765d-63fb-41fe-a111-ee2f1d03d62e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "22",
+                            Order = 21,
+                            TypeId = 3,
+                            Value = "22"
+                        },
+                        new
+                        {
+                            Id = new Guid("dbbe704a-8d6d-40e7-bd30-6974035b1fab"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "23",
+                            Order = 22,
+                            TypeId = 3,
+                            Value = "23"
+                        },
+                        new
+                        {
+                            Id = new Guid("cf7b9645-52ed-43a2-8267-267e0aed19b1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "24",
+                            Order = 23,
+                            TypeId = 3,
+                            Value = "24"
+                        },
+                        new
+                        {
+                            Id = new Guid("454788d6-d0ad-4c07-878c-da3fd3cd05e1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "25",
+                            Order = 24,
+                            TypeId = 3,
+                            Value = "25"
+                        },
+                        new
+                        {
+                            Id = new Guid("40d70d73-8582-4be6-a9e6-503b96ae3d49"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "26",
+                            Order = 25,
+                            TypeId = 3,
+                            Value = "26"
+                        },
+                        new
+                        {
+                            Id = new Guid("8f6610dc-ef46-4842-a57e-18d7aaa75931"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "27",
+                            Order = 26,
+                            TypeId = 3,
+                            Value = "27"
+                        },
+                        new
+                        {
+                            Id = new Guid("03858472-d4ce-47fd-9497-8051728766e4"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "28",
+                            Order = 27,
+                            TypeId = 3,
+                            Value = "28"
+                        },
+                        new
+                        {
+                            Id = new Guid("b1018e07-e90e-42ee-b399-19f3d0c14dd6"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "29",
+                            Order = 28,
+                            TypeId = 3,
+                            Value = "29"
+                        },
+                        new
+                        {
+                            Id = new Guid("a1669207-aa31-40fe-98d0-d941008d1655"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "30",
+                            Order = 29,
+                            TypeId = 3,
+                            Value = "30"
+                        },
+                        new
+                        {
+                            Id = new Guid("0936aa99-73e0-43de-b6df-334c1228a226"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "31",
+                            Order = 30,
+                            TypeId = 3,
+                            Value = "31"
+                        },
+                        new
+                        {
+                            Id = new Guid("626ca076-f09e-4a7a-8610-b7de6337b24a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 4,
+                            Value = "Первый"
+                        },
+                        new
+                        {
+                            Id = new Guid("032fbd02-67d0-4b8c-bed0-42629ab7113b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 4,
+                            Value = "Второй"
+                        },
+                        new
+                        {
+                            Id = new Guid("fa8a8f60-e41e-495e-ac86-35174d9976bf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 4,
+                            Value = "Третий"
+                        },
+                        new
+                        {
+                            Id = new Guid("d2f90168-2b49-42f2-820b-79db2c522adf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 4,
+                            Value = "Четвертый"
+                        },
+                        new
+                        {
+                            Id = new Guid("12bb8db2-cf7f-4113-baff-6883770f1ba5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 4,
+                            Value = "Последний"
+                        },
+                        new
+                        {
+                            Id = new Guid("18260e91-3fbe-4401-9edc-78dbc419370e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 5,
+                            Value = "Январь"
+                        },
+                        new
+                        {
+                            Id = new Guid("361526aa-3e1c-452e-bb44-0ade8521830d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 5,
+                            Value = "Февраль"
+                        },
+                        new
+                        {
+                            Id = new Guid("fad4bdb0-6c51-4810-a30b-6d031a0d4c46"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 5,
+                            Value = "Март"
+                        },
+                        new
+                        {
+                            Id = new Guid("06ab835d-3d3e-4057-8422-a553b6b40995"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 5,
+                            Value = "Апрель"
+                        },
+                        new
+                        {
+                            Id = new Guid("83f56b5d-b16b-4aa5-89d7-a253fee4e4ad"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 5,
+                            Value = "Май"
+                        },
+                        new
+                        {
+                            Id = new Guid("e679ec84-a9ee-4bed-a051-2b14edddcb18"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 5,
+                            Value = "Июнь"
+                        },
+                        new
+                        {
+                            Id = new Guid("d439808a-6a10-409b-8809-a755b7cca60b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 5,
+                            Value = "Июль"
+                        },
+                        new
+                        {
+                            Id = new Guid("6e9972c4-6bf7-4fe4-b4ea-bbb333fb69c8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 5,
+                            Value = "Август"
+                        },
+                        new
+                        {
+                            Id = new Guid("0883aac2-9d5b-4098-b672-c684d2a3a0c9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 5,
+                            Value = "Сентябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("5e6592bc-acb2-45a4-979b-fdecf8457453"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 5,
+                            Value = "Октябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("edd7cb49-d6a0-4969-b2d6-1967da69b336"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 5,
+                            Value = "Ноябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("dd695fb2-4ad0-4cda-a4df-e15059c56b24"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 5,
+                            Value = "Декабрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("2f473624-4eb3-49b4-a4b9-cc7fc08a50f5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 6,
+                            Value = "Января"
+                        },
+                        new
+                        {
+                            Id = new Guid("f0003490-a249-44bd-814f-4566999915d8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 6,
+                            Value = "Февраля"
+                        },
+                        new
+                        {
+                            Id = new Guid("f4c3fe38-aeaa-42f7-a9ba-190ea2dfe339"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 6,
+                            Value = "Марта"
+                        },
+                        new
+                        {
+                            Id = new Guid("06a8bd2f-68e1-42f5-961c-ac3b98a2181e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 6,
+                            Value = "Апреля"
+                        },
+                        new
+                        {
+                            Id = new Guid("963b9c41-d607-444a-9fe0-fe429590e326"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 6,
+                            Value = "Мая"
+                        },
+                        new
+                        {
+                            Id = new Guid("ec8554c8-dee4-49a1-b1b7-474ad8ec1473"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 6,
+                            Value = "Июня"
+                        },
+                        new
+                        {
+                            Id = new Guid("e15c7c63-e29f-41a3-9c82-f70eb6c24fde"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 6,
+                            Value = "Июля"
+                        },
+                        new
+                        {
+                            Id = new Guid("0b1f3cea-301a-4d74-9ce1-2cd93b41897d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 6,
+                            Value = "Августа"
+                        },
+                        new
+                        {
+                            Id = new Guid("e2fa3769-f66f-4753-a161-35adad7717a5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 6,
+                            Value = "Сентября"
+                        },
+                        new
+                        {
+                            Id = new Guid("c1de4aca-9f49-48ae-9279-cf9ec4092112"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 6,
+                            Value = "Октября"
+                        },
+                        new
+                        {
+                            Id = new Guid("a74b9ebd-bcd8-4537-b371-194de2fe0a4d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 6,
+                            Value = "Ноября"
+                        },
+                        new
+                        {
+                            Id = new Guid("852a5ebd-4545-494b-bc69-c27409a41adc"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 6,
+                            Value = "Декабря"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchValue", b =>
+                {
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TypeValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TypeConfigId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("JobGroupId", "TypeValueId", "TypeConfigId");
+
+                    b.HasIndex("TypeConfigId");
+
+                    b.HasIndex("TypeValueId");
+
+                    b.ToTable("EsppSchValues", "schedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ExcludeTypes", "schedule", t =>
+                        {
+                            t.HasComment("Расписание регламентной работы - Тип исключения");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("0595b8e0-f322-4661-b5e3-064af8fbe7cd"),
+                            Code = "None",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Нет исключений",
+                            EsppValue = "NONE",
+                            Title = "Нет исключений"
+                        },
+                        new
+                        {
+                            Id = new Guid("2b7a4356-9aaf-4e00-b444-42f0b5010e25"),
+                            Code = "Only",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Выполнить ТОЛЬКО В указанном календаре",
+                            EsppValue = "ONLY",
+                            Title = "Выполнить ТОЛЬКО В указанном календаре"
+                        },
+                        new
+                        {
+                            Id = new Guid("38cd9e64-27c1-4672-a805-2211952a48bd"),
+                            Code = "Except",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Выполнить везде, КРОМЕ указанного календаря",
+                            EsppValue = "EXCEPT",
+                            Title = "Выполнить везде, КРОМЕ указанного календаря"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ExcludeTypeCalendars", "schedule", t =>
+                        {
+                            t.HasComment("Расписание регламентной работы, исключение - Календарь");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("a26edb88-0267-4fbf-b7ec-d172b0a86c9c"),
+                            Code = "24x5",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "24x5",
+                            EsppValue = "24x5",
+                            Title = "24x5"
+                        },
+                        new
+                        {
+                            Id = new Guid("6834f1d5-ac51-43d5-974e-4c759d7bbf9f"),
+                            Code = "24x7",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "24x7",
+                            EsppValue = "24x7",
+                            Title = "24x7"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleResponseAreaTimeOffset", b =>
+                {
+                    b.Property<string>("ResponseArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<TimeSpan>("UtcTimeOffset")
+                        .HasColumnType("interval");
+
+                    b.HasKey("ResponseArea");
+
+                    b.ToTable("ResponseAreaTimeOffsets", "schedule", t =>
+                        {
+                            t.HasComment("Расписание в ЕСПП. Смещение часового пояса относительно МСК для зоны ответственности рабочей группы");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Setting", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("Settings");
+
+                    b.HasData(
+                        new
+                        {
+                            Name = "Initiator",
+                            Description = "Инициатор регламентной работы, указывается при создании шаблона в ЕСПП.",
+                            Value = "АКСЕНОВ АЛЕКСАНДР ЕВГЕНЬЕВИЧ (AKSENOVAE@GVC.OAO.RZD)"
+                        },
+                        new
+                        {
+                            Name = "ClosingCode",
+                            Description = "Код закрытия регламентной работы, указывается при создании шаблона в ЕСПП.",
+                            Value = "выполнен"
+                        },
+                        new
+                        {
+                            Name = "Category",
+                            Description = "Категория создаваемого объекта в ЕСПП",
+                            Value = "регламентная работа"
+                        },
+                        new
+                        {
+                            Name = "TemplatePrefixName",
+                            Description = "Префикс имени шаблона в ЕСПП",
+                            Value = "%PREFIX%-ЭИТИ-ПТК-ПАРР"
+                        },
+                        new
+                        {
+                            Name = "RobotAttemptsNumber",
+                            Description = "Количество попыток выполнения задания роботом",
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Name = "RobotWaitTime",
+                            Description = "Время ожидания выполнения роботом задания",
+                            Value = "00:10:00"
+                        },
+                        new
+                        {
+                            Name = "EsppScheduleTimezone",
+                            Description = "Расписание регламентной работы - В каком часовом поясе",
+                            Value = "MSK"
+                        },
+                        new
+                        {
+                            Name = "ScheduleRepeatRange",
+                            Description = "Расписание регламентной работы - Диапазн повторов",
+                            Value = "Отсутствует дата завершения"
+                        },
+                        new
+                        {
+                            Name = "OrderSearchDeltaDate",
+                            Description = "Промежуток времени для поиска нарядов в ЕСПП",
+                            Value = "01:30:00"
+                        },
+                        new
+                        {
+                            Name = "EsppRobotAccountTimeZoneHour",
+                            Description = "Таймзона УЗ роботов в ЕСПП, в часах (может быть положительная и отрицательная)",
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Name = "WeekendCacheTtl",
+                            Description = "Время хранения в кэше данных о выходных и рабочих днях",
+                            Value = "01:00:00"
+                        },
+                        new
+                        {
+                            Name = "TemplateNameConstantParts",
+                            Description = "Список неизменных частей имени шаблона",
+                            Value = "[{\"Name\":\"П-1\",\"Value\":\"ЭИТИ-ПАРР\"}]"
+                        },
+                        new
+                        {
+                            Name = "EsppUnitTag",
+                            Description = "Префикс тега в поле ЭК \"Дополнительная информация\"",
+                            Value = "ПАРР_"
+                        },
+                        new
+                        {
+                            Name = "JobIdForUnusedTemplates",
+                            Description = "Job в который перемещаем ниспользованные шаблоны",
+                            Value = "8f85a91c-a223-4686-bb69-1f0ee73624f2"
+                        },
+                        new
+                        {
+                            Name = "DefaultResponseAreaToTimeOffset",
+                            Description = "Зона ответственности для получения тайм зоны по умолчанию для расписаний",
+                            Value = "17-МСК"
+                        },
+                        new
+                        {
+                            Name = "MinRelationshipsThresholdPct",
+                            Description = "Минимально допустимый процент связей для продолжения синхронизации. Защищает от удаления данных, если передающая система АИХ ИТ передала аномально малый объем связей. 0 — Защита ОТКЛЮЧЕНА, 100 — Строгий режим.",
+                            Value = "97"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ProcessId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EsppId")
+                        .IsUnique();
+
+                    b.HasIndex("ProcessId");
+
+                    b.ToTable("Subprocesses");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskError", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ErrorMessage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("StackTrace")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TaskId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId");
+
+                    b.ToTable("Errors", "task", t =>
+                        {
+                            t.HasComment("Таблица ошибок заданий");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ProcessedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ProgressPercent")
+                        .HasColumnType("integer")
+                        .HasComment("Процент выполнения задачи");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StatusCode");
+
+                    b.HasIndex("TypeCode");
+
+                    b.ToTable("Tasks", "task", t =>
+                        {
+                            t.HasComment("Таблица заданий");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("Statuses", "task", t =>
+                        {
+                            t.HasComment("Таблица статусов заданий");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 0,
+                            Description = "Ожидание",
+                            Name = "Pending"
+                        },
+                        new
+                        {
+                            Code = 1,
+                            Description = "В работе",
+                            Name = "Processing"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "Выполнено успешно",
+                            Name = "Success"
+                        },
+                        new
+                        {
+                            Code = 3,
+                            Description = "Ошибка",
+                            Name = "Failed"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskType", b =>
+                {
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsSingleton")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MaxExecutionTimeMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RetentionDays")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("Types", "task", t =>
+                        {
+                            t.HasComment("Таблица типов заданий");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 0,
+                            Description = "Формирование данных для отчетности - Загруженность",
+                            IsSingleton = true,
+                            MaxExecutionTimeMinutes = 90,
+                            MaxRetries = 2,
+                            Name = "Workload",
+                            RetentionDays = 90
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("Index")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActiveSchedule")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActiveTemplate")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("LastRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("NextRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ScheduleEsppId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.HasIndex("StatusTypeId");
+
+                    b.HasIndex("UnitId");
+
+                    b.HasIndex("Name", "Index")
+                        .IsUnique();
+
+                    b.ToTable("Templates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateAddedToHistory")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActiveSchedule")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActiveTemplate")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LastRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("NextRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("ParentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ScheduleEsppId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusTypeId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("TemplateHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateStatusType", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TemplateStatusTypes", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 0,
+                            Description = "В работе",
+                            Name = "Used"
+                        },
+                        new
+                        {
+                            Id = 1,
+                            Description = "Не используется",
+                            Name = "Unused"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Обновляется",
+                            Name = "Updating"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Ошибка",
+                            Name = "Error"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("SubprocessId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubprocessId");
+
+                    b.ToTable("Tnks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.Unit", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastLogon")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Units", "unit", t =>
+                        {
+                            t.HasComment("Таблица с ЭК");
+
+                            t.HasCheckConstraint("CK_Units_Name_Upper", "\"Name\" = UPPER(\"Name\") AND \"Name\" IS NOT NULL AND LENGTH(\"Name\")>0");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitField", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AihitName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Code")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppName")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("IsMultipleValue")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AihitName");
+
+                    b.HasIndex("EsppName");
+
+                    b.ToTable("Fields", "unit", t =>
+                        {
+                            t.HasComment("Справочник полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldInUnitFieldValue", b =>
+                {
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("FieldId", "FieldValueId");
+
+                    b.HasIndex("FieldValueId");
+
+                    b.ToTable("FieldInFieldValues", "unit", t =>
+                        {
+                            t.HasComment("Значения полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Value")
+                        .IsUnique();
+
+                    b.ToTable("FieldValues", "unit", t =>
+                        {
+                            t.HasComment("Значения полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInUnit", b =>
+                {
+                    b.Property<Guid>("ParentUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChildUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateSynced")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ParentUnitId", "ChildUnitId");
+
+                    b.HasIndex("ChildUnitId");
+
+                    b.ToTable("UnitInUnits", "unit", t =>
+                        {
+                            t.HasComment("Таблица связей иерархии между ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInValue", b =>
+                {
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UnitId", "FieldId", "ValueId");
+
+                    b.HasIndex("ValueId");
+
+                    b.HasIndex("FieldId", "UnitId");
+
+                    b.HasIndex("FieldId", "ValueId");
+
+                    b.HasIndex("UnitId", "FieldId");
+
+                    b.ToTable("UnitInValues", "unit", t =>
+                        {
+                            t.HasComment("Таблица связи ЭК с полями и со значениями");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitKiiUnit", b =>
+                {
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UnitId");
+
+                    b.ToTable("KiiUnits", "unit", t =>
+                        {
+                            t.HasComment("Таблица - Список ЭК КИИ, которые учавствуют в групповых работах. Создавалась как временная");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", b =>
+                {
+                    b.Property<Guid>("FieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("FieldValueId");
+
+                    b.ToTable("RegionalEkPtkGroups", "unit", t =>
+                        {
+                            t.HasComment("Таблица - региональные группы ПТК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("LastLogon")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Ip")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.UsersInRole", b =>
+                {
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("RoleId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UsersInRoles");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.WeekendDay", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date")
+                        .IsUnique();
+
+                    b.ToTable("WeekendDays", "schedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.AgentHistoryLevel", "AgentHistoryLevel")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("HistoryLevelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Order", "Order")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("OrderId");
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AgentHistoryLevel");
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.DistributionPeriodType", "DistributionPeriodType")
+                        .WithMany("Periods")
+                        .HasForeignKey("Type")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DistributionPeriodType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "Group")
+                        .WithMany("Jobs")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Tnk", "Tnk")
+                        .WithMany("Jobs")
+                        .HasForeignKey("TnkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+
+                    b.Navigation("Tnk");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobAutoControl", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithOne("AutoControl")
+                        .HasForeignKey("PARR.Domain.Entities.JobEntities.JobAutoControl", "JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobFieldFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobFieldFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobEntities.JobUnitFilter", "UnitFilter")
+                        .WithMany("FieldFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobRelationshipFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobEntities.JobUnitFilter", "UnitFilter")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithMany("UnitFilters")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.UnitsInTemplate", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("UnitsInTemplate")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "UnitFieldValue")
+                        .WithMany("UnitsInTemplates")
+                        .HasForeignKey("UnitFieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("TemplatesInUnit")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Unit");
+
+                    b.Navigation("UnitFieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupType", "GroupType")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("GroupTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "GroupingUnitField")
+                        .WithMany("JobGroupWithGrouping")
+                        .HasForeignKey("GroupingUnitFieldId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", "ScheduleExcludeTypeCalendar")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("ScheduleExcludeTypeCalendarId");
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.ScheduleExcludeType", "ScheduleExcludeType")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("ScheduleExcludeTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GroupType");
+
+                    b.Navigation("GroupingUnitField");
+
+                    b.Navigation("ScheduleExcludeType");
+
+                    b.Navigation("ScheduleExcludeTypeCalendar");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithOne("AutoControl")
+                        .HasForeignKey("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", "JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.DistributionPeriod", "DistributionPeriod")
+                        .WithMany("GroupDistributionConfig")
+                        .HasForeignKey("DistributionPeriodId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "Group")
+                        .WithOne("DistributionConfig")
+                        .HasForeignKey("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", "GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DistributionPeriod");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupFieldFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobGroupFieldFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", "UnitFilter")
+                        .WithMany("FieldFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupRelationshipFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobGroupRelationshipFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", "UnitFilter")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithMany()
+                        .HasForeignKey("JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.OrderStatus", "NextStatus")
+                        .WithMany("OrdersNext")
+                        .HasForeignKey("NextStatusCode");
+
+                    b.HasOne("PARR.Domain.Entities.OrderStatus", "OrderStatus")
+                        .WithMany("Orders")
+                        .HasForeignKey("StatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("Orders")
+                        .HasForeignKey("TemplateId");
+
+                    b.Navigation("NextStatus");
+
+                    b.Navigation("OrderStatus");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("RobotCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("RobotStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Robot");
+
+                    b.Navigation("RobotStatus");
+
+                    b.Navigation("TaskStatus");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("RobotCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("RobotStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Robot");
+
+                    b.Navigation("RobotStatus");
+
+                    b.Navigation("TaskStatus");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", "RobotHistoryLevel")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("HistoryLevel")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotConfiguration", "RobotConfiguration")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("RobotConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "StatusTask")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RobotConfiguration");
+
+                    b.Navigation("RobotHistoryLevel");
+
+                    b.Navigation("StatusTask");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchType", "EsppSchType")
+                        .WithMany("EsppSchTypeConfigs")
+                        .HasForeignKey("TypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", "EsppSchTypeSchedule")
+                        .WithMany("EsppSchTypeConfigs")
+                        .HasForeignKey("TypeScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchType");
+
+                    b.Navigation("EsppSchTypeSchedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchType", "EsppSchType")
+                        .WithMany("EsppSchTypeValues")
+                        .HasForeignKey("TypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", "EsppSchTypeConfig")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("TypeConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeValue", "EsppSchTypeValue")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("TypeValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchTypeConfig");
+
+                    b.Navigation("EsppSchTypeValue");
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Process", "Process")
+                        .WithMany("Subprocesses")
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Process");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskError", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskItem", "TaskItem")
+                        .WithMany("TaskErrors")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TaskItem");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskStatus", "TaskStatus")
+                        .WithMany("Tasks")
+                        .HasForeignKey("StatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskType", "TaskType")
+                        .WithMany("Tasks")
+                        .HasForeignKey("TypeCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TaskStatus");
+
+                    b.Navigation("TaskType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithMany("Templates")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.TemplateStatusType", "StatusType")
+                        .WithMany("Templates")
+                        .HasForeignKey("StatusTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("Templates")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+
+                    b.Navigation("StatusType");
+
+                    b.Navigation("Unit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("TemplateHistories")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Subprocess", "Subprocess")
+                        .WithMany("Tnks")
+                        .HasForeignKey("SubprocessId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Subprocess");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldInUnitFieldValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "Field")
+                        .WithMany("UnitFieldValues")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "FieldValue")
+                        .WithMany("FieldValues")
+                        .HasForeignKey("FieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Field");
+
+                    b.Navigation("FieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInUnit", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "ChildUnit")
+                        .WithMany("ParentUnits")
+                        .HasForeignKey("ChildUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "ParentUnit")
+                        .WithMany("ChildUnits")
+                        .HasForeignKey("ParentUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildUnit");
+
+                    b.Navigation("ParentUnit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "Field")
+                        .WithMany("UnitInValues")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("UnitValues")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "Value")
+                        .WithMany("UnitInValues")
+                        .HasForeignKey("ValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Field");
+
+                    b.Navigation("Unit");
+
+                    b.Navigation("Value");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitKiiUnit", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithOne("UnitKii")
+                        .HasForeignKey("PARR.Domain.Entities.Unit.UnitKiiUnit", "UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Unit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "FieldValue")
+                        .WithOne("RegionalEkPtkGroup")
+                        .HasForeignKey("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", "FieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.UsersInRole", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Role", "Role")
+                        .WithMany("Users")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.User", "User")
+                        .WithMany("Roles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistoryLevel", b =>
+                {
+                    b.Navigation("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.Navigation("GroupDistributionConfig");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriodType", b =>
+                {
+                    b.Navigation("Periods");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.Navigation("AutoControl");
+
+                    b.Navigation("Templates");
+
+                    b.Navigation("UnitFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.Navigation("FieldFilters");
+
+                    b.Navigation("RelationshipFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.Navigation("AutoControl");
+
+                    b.Navigation("DistributionConfig");
+
+                    b.Navigation("EsppSchValues");
+
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupType", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.Navigation("FieldFilters");
+
+                    b.Navigation("RelationshipFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.Navigation("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.OrderStatus", b =>
+                {
+                    b.Navigation("Orders");
+
+                    b.Navigation("OrdersNext");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Process", b =>
+                {
+                    b.Navigation("Subprocesses");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
+                {
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
+                {
+                    b.Navigation("Users");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchType", b =>
+                {
+                    b.Navigation("EsppSchTypeConfigs");
+
+                    b.Navigation("EsppSchTypeValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.Navigation("EsppSchValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", b =>
+                {
+                    b.Navigation("EsppSchTypeConfigs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.Navigation("EsppSchValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeType", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.Navigation("Tnks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.Navigation("TaskErrors");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskStatus", b =>
+                {
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskType", b =>
+                {
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.Navigation("AgentHistories");
+
+                    b.Navigation("Orders");
+
+                    b.Navigation("RobotConfigurations");
+
+                    b.Navigation("TemplateHistories");
+
+                    b.Navigation("UnitsInTemplate");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateStatusType", b =>
+                {
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.Unit", b =>
+                {
+                    b.Navigation("ChildUnits");
+
+                    b.Navigation("ParentUnits");
+
+                    b.Navigation("Templates");
+
+                    b.Navigation("TemplatesInUnit");
+
+                    b.Navigation("UnitKii");
+
+                    b.Navigation("UnitValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitField", b =>
+                {
+                    b.Navigation("JobFieldFilters");
+
+                    b.Navigation("JobGroupFieldFilters");
+
+                    b.Navigation("JobGroupRelationshipFilters");
+
+                    b.Navigation("JobGroupWithGrouping");
+
+                    b.Navigation("RelationshipFilters");
+
+                    b.Navigation("UnitFieldValues");
+
+                    b.Navigation("UnitInValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldValue", b =>
+                {
+                    b.Navigation("FieldValues");
+
+                    b.Navigation("RegionalEkPtkGroup");
+
+                    b.Navigation("UnitInValues");
+
+                    b.Navigation("UnitsInTemplates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.User", b =>
+                {
+                    b.Navigation("Roles");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/PARR.DAL/Migrations/20260720233632_tblRobotsRename.cs b/PARR.DAL/Migrations/20260720233632_tblRobotsRename.cs
new file mode 100644
index 00000000..0cf7203d
--- /dev/null
+++ b/PARR.DAL/Migrations/20260720233632_tblRobotsRename.cs
@@ -0,0 +1,222 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PARR.DAL.Migrations
+{
+    /// <inheritdoc />
+    public partial class tblRobotsRename : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_RobotHistories_RobotConfigurations_RobotConfigurationId",
+                schema: "robot",
+                table: "RobotHistories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_RobotHistories_RobotHistoryLevels_HistoryLevel",
+                schema: "robot",
+                table: "RobotHistories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_RobotHistories_TaskStatuses_TaskStatusCode",
+                schema: "robot",
+                table: "RobotHistories");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_RobotHistoryLevels",
+                schema: "robot",
+                table: "RobotHistoryLevels");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_RobotHistories",
+                schema: "robot",
+                table: "RobotHistories");
+
+            migrationBuilder.RenameTable(
+                name: "RobotHistoryLevels",
+                schema: "robot",
+                newName: "HistoryLevels",
+                newSchema: "robot");
+
+            migrationBuilder.RenameTable(
+                name: "RobotHistories",
+                schema: "robot",
+                newName: "Histories",
+                newSchema: "robot");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_RobotHistories_TaskStatusCode",
+                schema: "robot",
+                table: "Histories",
+                newName: "IX_Histories_TaskStatusCode");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_RobotHistories_RobotConfigurationId_DateCreated",
+                schema: "robot",
+                table: "Histories",
+                newName: "IX_Histories_RobotConfigurationId_DateCreated");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_RobotHistories_HistoryLevel_DateCreated",
+                schema: "robot",
+                table: "Histories",
+                newName: "IX_Histories_HistoryLevel_DateCreated");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_RobotHistories_DateCreated",
+                schema: "robot",
+                table: "Histories",
+                newName: "IX_Histories_DateCreated");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_HistoryLevels",
+                schema: "robot",
+                table: "HistoryLevels",
+                column: "Level");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Histories",
+                schema: "robot",
+                table: "Histories",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Histories_HistoryLevels_HistoryLevel",
+                schema: "robot",
+                table: "Histories",
+                column: "HistoryLevel",
+                principalSchema: "robot",
+                principalTable: "HistoryLevels",
+                principalColumn: "Level",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Histories_RobotConfigurations_RobotConfigurationId",
+                schema: "robot",
+                table: "Histories",
+                column: "RobotConfigurationId",
+                principalTable: "RobotConfigurations",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Histories_TaskStatuses_TaskStatusCode",
+                schema: "robot",
+                table: "Histories",
+                column: "TaskStatusCode",
+                principalSchema: "robot",
+                principalTable: "TaskStatuses",
+                principalColumn: "Code",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Histories_HistoryLevels_HistoryLevel",
+                schema: "robot",
+                table: "Histories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Histories_RobotConfigurations_RobotConfigurationId",
+                schema: "robot",
+                table: "Histories");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Histories_TaskStatuses_TaskStatusCode",
+                schema: "robot",
+                table: "Histories");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_HistoryLevels",
+                schema: "robot",
+                table: "HistoryLevels");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Histories",
+                schema: "robot",
+                table: "Histories");
+
+            migrationBuilder.RenameTable(
+                name: "HistoryLevels",
+                schema: "robot",
+                newName: "RobotHistoryLevels",
+                newSchema: "robot");
+
+            migrationBuilder.RenameTable(
+                name: "Histories",
+                schema: "robot",
+                newName: "RobotHistories",
+                newSchema: "robot");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Histories_TaskStatusCode",
+                schema: "robot",
+                table: "RobotHistories",
+                newName: "IX_RobotHistories_TaskStatusCode");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Histories_RobotConfigurationId_DateCreated",
+                schema: "robot",
+                table: "RobotHistories",
+                newName: "IX_RobotHistories_RobotConfigurationId_DateCreated");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Histories_HistoryLevel_DateCreated",
+                schema: "robot",
+                table: "RobotHistories",
+                newName: "IX_RobotHistories_HistoryLevel_DateCreated");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Histories_DateCreated",
+                schema: "robot",
+                table: "RobotHistories",
+                newName: "IX_RobotHistories_DateCreated");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_RobotHistoryLevels",
+                schema: "robot",
+                table: "RobotHistoryLevels",
+                column: "Level");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_RobotHistories",
+                schema: "robot",
+                table: "RobotHistories",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RobotHistories_RobotConfigurations_RobotConfigurationId",
+                schema: "robot",
+                table: "RobotHistories",
+                column: "RobotConfigurationId",
+                principalTable: "RobotConfigurations",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RobotHistories_RobotHistoryLevels_HistoryLevel",
+                schema: "robot",
+                table: "RobotHistories",
+                column: "HistoryLevel",
+                principalSchema: "robot",
+                principalTable: "RobotHistoryLevels",
+                principalColumn: "Level",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RobotHistories_TaskStatuses_TaskStatusCode",
+                schema: "robot",
+                table: "RobotHistories",
+                column: "TaskStatusCode",
+                principalSchema: "robot",
+                principalTable: "TaskStatuses",
+                principalColumn: "Code",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.Designer.cs b/PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.Designer.cs
new file mode 100644
index 00000000..6b3d590c
--- /dev/null
+++ b/PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.Designer.cs
@@ -0,0 +1,4133 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using PARR.DAL.Context;
+
+#nullable disable
+
+namespace PARR.DAL.Migrations
+{
+    [DbContext(typeof(DataContext))]
+    [Migration("20260721013444_tblTemplateRenamePendings")]
+    partial class tblTemplateRenamePendings
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.16")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("HistoryLevelId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("OrderId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HistoryLevelId");
+
+                    b.HasIndex("OrderId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistoryLevel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AgentHistoryLevels");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Агент начал выполнять задание",
+                            Name = "Start"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Агент завершил выполнение задания",
+                            Name = "End"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Duration")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Type");
+
+                    b.ToTable("DistributionPeriods", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("9bd0bfa8-c316-480b-a001-e09ffe8c9340"),
+                            Duration = "7",
+                            Name = "Еженедельно",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("3a7341a8-085c-461c-babc-6b78dd5d2c67"),
+                            Duration = "30",
+                            Name = "Ежемесячно",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("0ad2dfdb-3833-46d9-979a-c408b7eadc6c"),
+                            Duration = "90",
+                            Name = "Каждые 90 дней",
+                            Type = "Day"
+                        },
+                        new
+                        {
+                            Id = new Guid("31dd3947-8471-4f09-852c-a4f075f1ba7f"),
+                            Duration = "182",
+                            Name = "Каждые пол года",
+                            Type = "Day"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriodType", b =>
+                {
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Type");
+
+                    b.ToTable("DistributionPeriodTypes", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Type = "Day",
+                            Description = "День"
+                        },
+                        new
+                        {
+                            Type = "Month",
+                            Description = "Месяц"
+                        },
+                        new
+                        {
+                            Type = "Year",
+                            Description = "Год"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("IsParentRelationships")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("MaxValueRelationships")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("MinValueRelationships")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ResponseAreaMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateNameMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TnkId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorkGroupMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("TnkId");
+
+                    b.ToTable("Jobs", "job", t =>
+                        {
+                            t.HasComment("Таблица видов работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobAutoControl", b =>
+                {
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("InitUsedScheduleState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("InitUsedTemplateState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsEnable")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("JobId");
+
+                    b.ToTable("AutoControls", "job", t =>
+                        {
+                            t.HasComment("Таблица управления автоконтролем для работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobFieldFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FieldId");
+
+                    b.HasIndex("UnitFilterId");
+
+                    b.ToTable("FieldFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobRelationshipFilter", b =>
+                {
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsFullMatch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsParent")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("UnitFilterId", "FieldId");
+
+                    b.HasIndex("FieldId");
+
+                    b.ToTable("RelationshipFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица фильтров связей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("UnitFilter")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.ToTable("UnitFilters", "job", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки ЭК, описание полей в АСУ ЕСПП");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.UnitsInTemplate", b =>
+                {
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UnitFieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("TemplateId", "UnitId", "UnitFieldValueId");
+
+                    b.HasIndex("UnitFieldValueId");
+
+                    b.HasIndex("UnitId");
+
+                    b.ToTable("UnitsInTemplates", "job", t =>
+                        {
+                            t.HasComment("Таблица связи ЭК в шаблонах");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AgentName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AgentScript")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("AgentTimeOutSec")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FullDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GroupName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("GroupTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("GroupingUnitFieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsAgent")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsAutoDistributionEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool?>("IsGroupByResponsible")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsResponseAreaTimezone")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("ReferenceDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("ScheduleExcludeTypeCalendarId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ScheduleExcludeTypeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ShortDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Solution")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateDuration")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("UserTimeZoneOffsetMinutes")
+                        .HasColumnType("integer")
+                        .HasComment("Смещение часового пояса пользователя в минутах относительно UTC на момент ReferenceDate");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupTypeId");
+
+                    b.HasIndex("GroupingUnitFieldId");
+
+                    b.HasIndex("ScheduleExcludeTypeCalendarId");
+
+                    b.HasIndex("ScheduleExcludeTypeId");
+
+                    b.ToTable("Groups", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания групп работ, для реализации зонтиков");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", b =>
+                {
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("InitUsedScheduleState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("InitUsedTemplateState")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsEnable")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("JobGroupId");
+
+                    b.ToTable("AutoControls", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица управления автоконтролем для группы работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", b =>
+                {
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("DistributionPeriodId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsExcludeWeekends")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsGroupingByWorkGroup")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("GroupId");
+
+                    b.HasIndex("DistributionPeriodId");
+
+                    b.ToTable("GroupDistributionConfigs", "jobGroup", t =>
+                        {
+                            t.HasComment("Настройки автораспределения для группы работ");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupFieldFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FieldId")
+                        .HasDatabaseName("IX_FieldFilters_FieldId1");
+
+                    b.HasIndex("UnitFilterId")
+                        .HasDatabaseName("IX_FieldFilters_UnitFilterId1");
+
+                    b.ToTable("FieldFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupRelationshipFilter", b =>
+                {
+                    b.Property<Guid>("UnitFilterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsFullMatch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInverse")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsParent")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ValueMask")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("UnitFilterId", "FieldId");
+
+                    b.HasIndex("FieldId")
+                        .HasDatabaseName("IX_RelationshipFilters_FieldId1");
+
+                    b.ToTable("RelationshipFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица фильтров связей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsAllowJobUnitFilter")
+                        .HasColumnType("boolean")
+                        .HasComment("Разрешить Job фильтры. Влияет только на интерфейс. Мэтчер собирает все фильтры из группы и работ всегда.");
+
+                    b.Property<bool>("IsJobGroupAutoControl")
+                        .HasColumnType("boolean")
+                        .HasComment("Автоконтролем управляет JobGroup? true - да JobGroup, false - Job. Влияет на интерфейс и на логику работы автоконтроля.");
+
+                    b.Property<bool>("IsRelationshipsAllowed")
+                        .HasColumnType("boolean")
+                        .HasComment("Разрешена настройка кол-ва связей");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GroupTypes", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица типов групп работ");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("4fa62e79-86bb-47c2-be1a-72a716a170fa"),
+                            Code = 0,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Обычный",
+                            IsAllowJobUnitFilter = true,
+                            IsJobGroupAutoControl = false,
+                            IsRelationshipsAllowed = false,
+                            Name = "Simple"
+                        },
+                        new
+                        {
+                            Id = new Guid("6ec58b1a-5c40-47b9-b036-4fa490e8d503"),
+                            Code = 1,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Зонтик",
+                            IsAllowJobUnitFilter = false,
+                            IsJobGroupAutoControl = true,
+                            IsRelationshipsAllowed = true,
+                            Name = "Umbrella"
+                        },
+                        new
+                        {
+                            Id = new Guid("318625e5-f833-436a-99df-2a382a1e71c7"),
+                            Code = 2,
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Сгруппированный",
+                            IsAllowJobUnitFilter = false,
+                            IsJobGroupAutoControl = true,
+                            IsRelationshipsAllowed = true,
+                            Name = "Group"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("UnitFilter")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobGroupId");
+
+                    b.ToTable("UnitFilters", "jobGroup", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки ЭК, описание полей в АСУ ЕСПП");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpirationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("GenerateDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("NextStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Number")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorkGroup")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NextStatusCode");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.HasIndex("StatusCode");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("Orders");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.OrderStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("OrderStatuses");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 1,
+                            Description = "1-Направлен в группу",
+                            Name = "New"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "2-В работе",
+                            Name = "InWork"
+                        },
+                        new
+                        {
+                            Code = 3,
+                            Description = "3-Приостановлен",
+                            Name = "Stop"
+                        },
+                        new
+                        {
+                            Code = 4,
+                            Description = "4-Выполнен",
+                            Name = "Complete"
+                        },
+                        new
+                        {
+                            Code = 5,
+                            Description = "5-Закрыт",
+                            Name = "Closed"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.ParrComponent", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ParrComponents");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 0,
+                            Description = "API",
+                            Name = "Api"
+                        },
+                        new
+                        {
+                            Id = 1,
+                            Description = "Загрузчик из АИХИТ",
+                            Name = "AihitLoader"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Синхронизатор АИХИТ",
+                            Name = "AihitSyncer"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Загрузчик нарядов из ЕСПП",
+                            Name = "EsppOrderLoader"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Управление нарядами ЕСПП",
+                            Name = "EsppOrderManager"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Синхронизатор расписаний",
+                            Name = "EsppScheduleSync"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Синхронизатор шаблонов",
+                            Name = "EsppTemplateSync"
+                        },
+                        new
+                        {
+                            Id = 7,
+                            Description = "Генератор шаблонов",
+                            Name = "GeneratorTemplates"
+                        },
+                        new
+                        {
+                            Id = 8,
+                            Description = "Авто-контроль РР",
+                            Name = "JobAutoControl"
+                        },
+                        new
+                        {
+                            Id = 9,
+                            Description = "Связывание нарядов ЕСПП с ПАРР (шаблонами, агентами)",
+                            Name = "Master"
+                        },
+                        new
+                        {
+                            Id = 10,
+                            Description = "Рассчет даты следующего срабатывания",
+                            Name = "NextRun"
+                        },
+                        new
+                        {
+                            Id = 11,
+                            Description = "Активатор шаблонов / расписаний",
+                            Name = "TemplateActivator"
+                        },
+                        new
+                        {
+                            Id = 12,
+                            Description = "Автораспределение РР",
+                            Name = "TemplateDistributor"
+                        },
+                        new
+                        {
+                            Id = 13,
+                            Description = "Генератор шаблонов",
+                            Name = "TemplateTaskGenerator"
+                        },
+                        new
+                        {
+                            Id = 14,
+                            Description = "Генератор кэша отчетов workload",
+                            Name = "WorkloadBuilder"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Process", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EsppId")
+                        .IsUnique();
+
+                    b.ToTable("Processes");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptsNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastRobotStatusUpdated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RobotCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RobotStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RobotCode");
+
+                    b.HasIndex("RobotStatusCode");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("TemplateId", "RobotCode")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateId", "RobotStatusCode");
+
+                    b.HasIndex("TemplateId", "TaskStatusCode");
+
+                    b.ToTable("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Robots", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 1,
+                            Description = "Робот по созданию/изменению шаблона наряда ЕСПП",
+                            Name = "TemplateOrder"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "Робот по созданию/изменению расписания шаблона наряда в ЕСПП",
+                            Name = "ScheduleOrder"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("integer")
+                        .HasComment("Количество заданий в этой комбинации статусов");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RobotCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RobotStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RobotStatusCode");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("RobotCode", "DateCreated");
+
+                    b.ToTable("ConfigurationSnapshots", "robot", t =>
+                        {
+                            t.HasComment("Снимки заданий роботам");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int>("HistoryLevel")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("RobotConfigurationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RobotId")
+                        .HasColumnType("text")
+                        .HasComment("Идентификатор робота. Форматы: H20-R1-T, H20-R1-S, H20-R1-ET, H20-R1-ES.");
+
+                    b.Property<string>("RobotIp")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RobotMessage")
+                        .HasColumnType("text");
+
+                    b.Property<int>("TaskStatusCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateCreated");
+
+                    b.HasIndex("TaskStatusCode");
+
+                    b.HasIndex("HistoryLevel", "DateCreated")
+                        .IsDescending(false, true);
+
+                    b.HasIndex("RobotConfigurationId", "DateCreated");
+
+                    b.ToTable("Histories", "robot");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
+                {
+                    b.Property<int>("Level")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Level"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Level");
+
+                    b.ToTable("HistoryLevels", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Level = 1,
+                            Description = "Робот начал работу ",
+                            Name = "Start"
+                        },
+                        new
+                        {
+                            Level = 5,
+                            Description = "Информация",
+                            Name = "Information"
+                        },
+                        new
+                        {
+                            Level = 10,
+                            Description = "Ошибка",
+                            Name = "Error"
+                        },
+                        new
+                        {
+                            Level = 15,
+                            Description = "Успешно завершил работу",
+                            Name = "Complete"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("character varying(45)")
+                        .HasComment("Текущий IP-адрес сервера");
+
+                    b.Property<int>("MaxRobots")
+                        .HasColumnType("integer")
+                        .HasComment("Максимально разрешенное количество роботов на сервере");
+
+                    b.Property<int>("ScheduleRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по расписаниям");
+
+                    b.Property<int>("TemplateRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по шаблонам");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Ip", "DateCreated");
+
+                    b.ToTable("Snapshots", "robot", t =>
+                        {
+                            t.HasComment("Снимки роботов");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("RobotStatuses", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 11,
+                            Description = "Ожидание, ждет пока робот возьмет в работу.",
+                            Name = "Wait"
+                        },
+                        new
+                        {
+                            Code = 22,
+                            Description = "Робот взял в работу.",
+                            Name = "InProgress"
+                        },
+                        new
+                        {
+                            Code = 33,
+                            Description = "Ошибка отработки роботом. Требует ручного вмешательства.",
+                            Name = "Error"
+                        },
+                        new
+                        {
+                            Code = 44,
+                            Description = "Робот успешно отработал.",
+                            Name = "Complete"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("TaskStatuses", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 10,
+                            Description = "Требуется создание объекта в ЕСПП",
+                            Name = "Creating"
+                        },
+                        new
+                        {
+                            Code = 20,
+                            Description = "Требуется обновление объекта в ЕСПП",
+                            Name = "Updating"
+                        },
+                        new
+                        {
+                            Code = 30,
+                            Description = "Нормальное состояние объекта в ЕСПП и ПАРР. Объект в ПАРР соответствует объекту в ЕСПП",
+                            Name = "Ok"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Roles");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("c8f2f144-e6c2-45d7-ba66-5e9bbd376376"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Администратор",
+                            Name = "administrator"
+                        },
+                        new
+                        {
+                            Id = new Guid("13bca225-7fa4-42fa-9d80-d2d46de261fe"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Description = "Робот ЕСПП",
+                            Name = "espp-robot"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EsppSchTypes", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Через интервал",
+                            Name = "Interval"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "День недели: пнд, вт...",
+                            Name = "DayOfWeek"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Число месяца: 1,2,3,4",
+                            Name = "DayOfMonth"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Каждый: первый, второй, третий, четвертый, последний",
+                            Name = "Order"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Месяц: январь, февраль...",
+                            Name = "Month"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Месяц (родительный падеж): января, февраля...",
+                            Name = "MonthGenitive"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeScheduleId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TypeId");
+
+                    b.HasIndex("TypeScheduleId", "TypeId")
+                        .IsUnique();
+
+                    b.ToTable("EsppSchTypeConfigs", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("d2693562-b3eb-41e9-97db-c6b5d2ef1bea"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 1,
+                            TypeScheduleId = 1
+                        },
+                        new
+                        {
+                            Id = new Guid("06b2e7aa-6927-4fbf-99fb-67c92a4fce8a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 2,
+                            TypeScheduleId = 2
+                        },
+                        new
+                        {
+                            Id = new Guid("78079071-ff80-417e-9bb0-d928cec853e7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 3,
+                            TypeScheduleId = 3
+                        },
+                        new
+                        {
+                            Id = new Guid("accb1d46-e1c1-4396-9182-4c0766155921"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 4,
+                            TypeScheduleId = 4
+                        },
+                        new
+                        {
+                            Id = new Guid("162ffe73-2428-4abe-8f83-235c2593664c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 2,
+                            TypeScheduleId = 4
+                        },
+                        new
+                        {
+                            Id = new Guid("8470d1ef-165d-42fc-ab05-8203e4d263cf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 5,
+                            TypeScheduleId = 5
+                        },
+                        new
+                        {
+                            Id = new Guid("006900b5-f65c-413e-bc67-09e6dae60b7c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 3,
+                            TypeScheduleId = 5
+                        },
+                        new
+                        {
+                            Id = new Guid("85635bc8-f17a-46b8-9c15-8615761be3d9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 0,
+                            TypeId = 4,
+                            TypeScheduleId = 6
+                        },
+                        new
+                        {
+                            Id = new Guid("439460c2-deca-4b54-80e7-2f20806696ec"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 1,
+                            TypeId = 2,
+                            TypeScheduleId = 6
+                        },
+                        new
+                        {
+                            Id = new Guid("5c63ad8c-e9b4-43fd-9d24-5c2eed80dadd"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            Order = 2,
+                            TypeId = 6,
+                            TypeScheduleId = 6
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EsppSchTypeSchedules", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Description = "Регулярно",
+                            Name = "Regularly"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Еженедельно",
+                            Name = "Weekly"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Ежемесячно",
+                            Name = "Monthly"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            Description = "Ежемесячно-2",
+                            Name = "Monthly2"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            Description = "Ежегодно",
+                            Name = "Annually"
+                        },
+                        new
+                        {
+                            Id = 6,
+                            Description = "Ежегодно-2",
+                            Name = "Annually2"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppExportValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TypeId");
+
+                    b.ToTable("EsppSchTypeValues", "schedule");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("6e3b5dd2-b2f7-40bc-bace-15bfa6bbd4ff"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "01:00:00",
+                            Order = 0,
+                            TypeId = 1,
+                            Value = "Каждый час"
+                        },
+                        new
+                        {
+                            Id = new Guid("4df04834-f14f-43d9-8984-334f080f4107"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "02:00:00",
+                            Order = 1,
+                            TypeId = 1,
+                            Value = "Каждые 2 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("dab6e3f9-2385-4966-b77c-133ad233c592"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "03:00:00",
+                            Order = 2,
+                            TypeId = 1,
+                            Value = "Каждые 3 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("035f485d-8451-47df-bfaa-ba4dd36cf146"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "04:00:00",
+                            Order = 3,
+                            TypeId = 1,
+                            Value = "Каждые 4 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("d627daa7-3eed-4571-acae-ffbb3c5bedb9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "06:00:00",
+                            Order = 4,
+                            TypeId = 1,
+                            Value = "Каждые 6 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("ae0a0015-0f1e-4496-b71e-6244f7e321e7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12:00:00",
+                            Order = 5,
+                            TypeId = 1,
+                            Value = "Каждые 12 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("8df097aa-9860-4a62-9675-a8eecd3f2ce7"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1 00:00:00",
+                            Order = 6,
+                            TypeId = 1,
+                            Value = "Ежедневно"
+                        },
+                        new
+                        {
+                            Id = new Guid("dee32e60-c1a1-4206-98bc-aa03deabfdf6"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3 00:00:00",
+                            Order = 7,
+                            TypeId = 1,
+                            Value = "Каждые 72 часа"
+                        },
+                        new
+                        {
+                            Id = new Guid("e0465fbf-e3a5-4486-9f53-5bb85c6feeca"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4 00:00:00",
+                            Order = 8,
+                            TypeId = 1,
+                            Value = "Каждые 96 часов"
+                        },
+                        new
+                        {
+                            Id = new Guid("4e3f73d1-a0f3-4dd1-bca9-68ada0dd5ce2"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "14 00:00:00",
+                            Order = 9,
+                            TypeId = 1,
+                            Value = "Каждые 2 недели"
+                        },
+                        new
+                        {
+                            Id = new Guid("55833417-6a24-42f6-bcc2-5d032f883202"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "60 00:00:00",
+                            Order = 10,
+                            TypeId = 1,
+                            Value = "Каждые 60 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("7fefa052-29db-4ce5-9c57-2fd9ff855f21"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "80 00:00:00",
+                            Order = 11,
+                            TypeId = 1,
+                            Value = "Каждые 80 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("b0ca99f9-5ee0-45b3-bb80-948f82b1fcb1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "90 00:00:00",
+                            Order = 12,
+                            TypeId = 1,
+                            Value = "Каждые 90 дней"
+                        },
+                        new
+                        {
+                            Id = new Guid("086f7a37-9848-423a-a3cc-36dbb5ad43e3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "182 00:00:00",
+                            Order = 13,
+                            TypeId = 1,
+                            Value = "Каждые полгода"
+                        },
+                        new
+                        {
+                            Id = new Guid("f2da9e02-d619-4517-a598-374880a8c8e8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "540 00:00:00",
+                            Order = 14,
+                            TypeId = 1,
+                            Value = "Каждые 1,5 года"
+                        },
+                        new
+                        {
+                            Id = new Guid("f38d7d30-8923-4ea0-aa7c-5b251e19ab61"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1095 00:00:00",
+                            Order = 15,
+                            TypeId = 1,
+                            Value = "Каждые 3 года"
+                        },
+                        new
+                        {
+                            Id = new Guid("b7303461-9a30-43fa-8e55-305aa13f186f"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 2,
+                            Value = "Понедельник"
+                        },
+                        new
+                        {
+                            Id = new Guid("e951135e-71f2-4262-9342-df4d5315ab6c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 2,
+                            Value = "Вторник"
+                        },
+                        new
+                        {
+                            Id = new Guid("c34d5375-70e7-4632-b3af-30e279a0621a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 2,
+                            Value = "Среда"
+                        },
+                        new
+                        {
+                            Id = new Guid("ec9540df-c2de-4bda-a063-34d02d4b6e03"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 2,
+                            Value = "Четверг"
+                        },
+                        new
+                        {
+                            Id = new Guid("2ed85534-4684-4eb2-9ccb-e264d212c945"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 2,
+                            Value = "Пятница"
+                        },
+                        new
+                        {
+                            Id = new Guid("a6804315-96ef-484e-82ee-c5795694468b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 2,
+                            Value = "Суббота"
+                        },
+                        new
+                        {
+                            Id = new Guid("eb71e699-937f-4894-9688-f7a7f95e5e58"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 2,
+                            Value = "Воскресенье"
+                        },
+                        new
+                        {
+                            Id = new Guid("e86adbfb-3345-4e0c-aa3b-b4418f9cfe88"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 3,
+                            Value = "1"
+                        },
+                        new
+                        {
+                            Id = new Guid("5b4d7ca6-31e7-475b-b7c8-13c6680c3dc3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 3,
+                            Value = "2"
+                        },
+                        new
+                        {
+                            Id = new Guid("0da03db0-9404-425d-bea1-5da0c9b60b59"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 3,
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Id = new Guid("199474c8-0a77-47e5-aab8-ba33c216cc9e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 3,
+                            Value = "4"
+                        },
+                        new
+                        {
+                            Id = new Guid("e6619da1-f7e8-45b9-bbd3-9c17bec2ccd3"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 3,
+                            Value = "5"
+                        },
+                        new
+                        {
+                            Id = new Guid("a8708763-c838-49a5-95fe-bf4f73518d71"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 3,
+                            Value = "6"
+                        },
+                        new
+                        {
+                            Id = new Guid("7ec056aa-820c-4900-96cb-4564d2ea6398"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 3,
+                            Value = "7"
+                        },
+                        new
+                        {
+                            Id = new Guid("554d7d0c-91b1-4b81-b94d-1ee864192962"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 3,
+                            Value = "8"
+                        },
+                        new
+                        {
+                            Id = new Guid("8b7847a4-23de-4199-8aad-3b5c0323b5a2"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 3,
+                            Value = "9"
+                        },
+                        new
+                        {
+                            Id = new Guid("fb7f41ca-950b-4dc1-a0a6-bd9a221ab2ad"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 3,
+                            Value = "10"
+                        },
+                        new
+                        {
+                            Id = new Guid("a28b530f-ea38-4a2c-a16b-0b7fa3770d3c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 3,
+                            Value = "11"
+                        },
+                        new
+                        {
+                            Id = new Guid("7a004a11-32e1-40ae-ab35-0d3dc3a69785"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 3,
+                            Value = "12"
+                        },
+                        new
+                        {
+                            Id = new Guid("e0f2f4d1-4a5e-4997-8336-83c3c35f38df"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "13",
+                            Order = 12,
+                            TypeId = 3,
+                            Value = "13"
+                        },
+                        new
+                        {
+                            Id = new Guid("9c5aaf48-88ec-4c67-b936-2be45550f8bf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "14",
+                            Order = 13,
+                            TypeId = 3,
+                            Value = "14"
+                        },
+                        new
+                        {
+                            Id = new Guid("8dbd680c-ce49-4d2e-8a1a-05619685e240"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "15",
+                            Order = 14,
+                            TypeId = 3,
+                            Value = "15"
+                        },
+                        new
+                        {
+                            Id = new Guid("2f476f70-b1ef-419d-aad5-3911f1e3231f"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "16",
+                            Order = 15,
+                            TypeId = 3,
+                            Value = "16"
+                        },
+                        new
+                        {
+                            Id = new Guid("2c635ce2-fc18-47be-b3e9-98c211abf312"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "17",
+                            Order = 16,
+                            TypeId = 3,
+                            Value = "17"
+                        },
+                        new
+                        {
+                            Id = new Guid("f9d5b03b-624a-4f9f-8da3-1490ea5d2914"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "18",
+                            Order = 17,
+                            TypeId = 3,
+                            Value = "18"
+                        },
+                        new
+                        {
+                            Id = new Guid("4f4b249c-db60-4582-86ed-75cfee4edd0c"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "19",
+                            Order = 18,
+                            TypeId = 3,
+                            Value = "19"
+                        },
+                        new
+                        {
+                            Id = new Guid("220a1464-4d39-416c-b4b2-3093eb007298"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "20",
+                            Order = 19,
+                            TypeId = 3,
+                            Value = "20"
+                        },
+                        new
+                        {
+                            Id = new Guid("c887ca60-b05d-4d3c-ad1f-223c879b1a6d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "21",
+                            Order = 20,
+                            TypeId = 3,
+                            Value = "21"
+                        },
+                        new
+                        {
+                            Id = new Guid("2905765d-63fb-41fe-a111-ee2f1d03d62e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "22",
+                            Order = 21,
+                            TypeId = 3,
+                            Value = "22"
+                        },
+                        new
+                        {
+                            Id = new Guid("dbbe704a-8d6d-40e7-bd30-6974035b1fab"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "23",
+                            Order = 22,
+                            TypeId = 3,
+                            Value = "23"
+                        },
+                        new
+                        {
+                            Id = new Guid("cf7b9645-52ed-43a2-8267-267e0aed19b1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "24",
+                            Order = 23,
+                            TypeId = 3,
+                            Value = "24"
+                        },
+                        new
+                        {
+                            Id = new Guid("454788d6-d0ad-4c07-878c-da3fd3cd05e1"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "25",
+                            Order = 24,
+                            TypeId = 3,
+                            Value = "25"
+                        },
+                        new
+                        {
+                            Id = new Guid("40d70d73-8582-4be6-a9e6-503b96ae3d49"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "26",
+                            Order = 25,
+                            TypeId = 3,
+                            Value = "26"
+                        },
+                        new
+                        {
+                            Id = new Guid("8f6610dc-ef46-4842-a57e-18d7aaa75931"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "27",
+                            Order = 26,
+                            TypeId = 3,
+                            Value = "27"
+                        },
+                        new
+                        {
+                            Id = new Guid("03858472-d4ce-47fd-9497-8051728766e4"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "28",
+                            Order = 27,
+                            TypeId = 3,
+                            Value = "28"
+                        },
+                        new
+                        {
+                            Id = new Guid("b1018e07-e90e-42ee-b399-19f3d0c14dd6"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "29",
+                            Order = 28,
+                            TypeId = 3,
+                            Value = "29"
+                        },
+                        new
+                        {
+                            Id = new Guid("a1669207-aa31-40fe-98d0-d941008d1655"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "30",
+                            Order = 29,
+                            TypeId = 3,
+                            Value = "30"
+                        },
+                        new
+                        {
+                            Id = new Guid("0936aa99-73e0-43de-b6df-334c1228a226"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "31",
+                            Order = 30,
+                            TypeId = 3,
+                            Value = "31"
+                        },
+                        new
+                        {
+                            Id = new Guid("626ca076-f09e-4a7a-8610-b7de6337b24a"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 4,
+                            Value = "Первый"
+                        },
+                        new
+                        {
+                            Id = new Guid("032fbd02-67d0-4b8c-bed0-42629ab7113b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 4,
+                            Value = "Второй"
+                        },
+                        new
+                        {
+                            Id = new Guid("fa8a8f60-e41e-495e-ac86-35174d9976bf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 4,
+                            Value = "Третий"
+                        },
+                        new
+                        {
+                            Id = new Guid("d2f90168-2b49-42f2-820b-79db2c522adf"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 4,
+                            Value = "Четвертый"
+                        },
+                        new
+                        {
+                            Id = new Guid("12bb8db2-cf7f-4113-baff-6883770f1ba5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 4,
+                            Value = "Последний"
+                        },
+                        new
+                        {
+                            Id = new Guid("18260e91-3fbe-4401-9edc-78dbc419370e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 5,
+                            Value = "Январь"
+                        },
+                        new
+                        {
+                            Id = new Guid("361526aa-3e1c-452e-bb44-0ade8521830d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 5,
+                            Value = "Февраль"
+                        },
+                        new
+                        {
+                            Id = new Guid("fad4bdb0-6c51-4810-a30b-6d031a0d4c46"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 5,
+                            Value = "Март"
+                        },
+                        new
+                        {
+                            Id = new Guid("06ab835d-3d3e-4057-8422-a553b6b40995"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 5,
+                            Value = "Апрель"
+                        },
+                        new
+                        {
+                            Id = new Guid("83f56b5d-b16b-4aa5-89d7-a253fee4e4ad"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 5,
+                            Value = "Май"
+                        },
+                        new
+                        {
+                            Id = new Guid("e679ec84-a9ee-4bed-a051-2b14edddcb18"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 5,
+                            Value = "Июнь"
+                        },
+                        new
+                        {
+                            Id = new Guid("d439808a-6a10-409b-8809-a755b7cca60b"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 5,
+                            Value = "Июль"
+                        },
+                        new
+                        {
+                            Id = new Guid("6e9972c4-6bf7-4fe4-b4ea-bbb333fb69c8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 5,
+                            Value = "Август"
+                        },
+                        new
+                        {
+                            Id = new Guid("0883aac2-9d5b-4098-b672-c684d2a3a0c9"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 5,
+                            Value = "Сентябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("5e6592bc-acb2-45a4-979b-fdecf8457453"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 5,
+                            Value = "Октябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("edd7cb49-d6a0-4969-b2d6-1967da69b336"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 5,
+                            Value = "Ноябрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("dd695fb2-4ad0-4cda-a4df-e15059c56b24"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 5,
+                            Value = "Декабрь"
+                        },
+                        new
+                        {
+                            Id = new Guid("2f473624-4eb3-49b4-a4b9-cc7fc08a50f5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "1",
+                            Order = 0,
+                            TypeId = 6,
+                            Value = "Января"
+                        },
+                        new
+                        {
+                            Id = new Guid("f0003490-a249-44bd-814f-4566999915d8"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "2",
+                            Order = 1,
+                            TypeId = 6,
+                            Value = "Февраля"
+                        },
+                        new
+                        {
+                            Id = new Guid("f4c3fe38-aeaa-42f7-a9ba-190ea2dfe339"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "3",
+                            Order = 2,
+                            TypeId = 6,
+                            Value = "Марта"
+                        },
+                        new
+                        {
+                            Id = new Guid("06a8bd2f-68e1-42f5-961c-ac3b98a2181e"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "4",
+                            Order = 3,
+                            TypeId = 6,
+                            Value = "Апреля"
+                        },
+                        new
+                        {
+                            Id = new Guid("963b9c41-d607-444a-9fe0-fe429590e326"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "5",
+                            Order = 4,
+                            TypeId = 6,
+                            Value = "Мая"
+                        },
+                        new
+                        {
+                            Id = new Guid("ec8554c8-dee4-49a1-b1b7-474ad8ec1473"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "6",
+                            Order = 5,
+                            TypeId = 6,
+                            Value = "Июня"
+                        },
+                        new
+                        {
+                            Id = new Guid("e15c7c63-e29f-41a3-9c82-f70eb6c24fde"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "7",
+                            Order = 6,
+                            TypeId = 6,
+                            Value = "Июля"
+                        },
+                        new
+                        {
+                            Id = new Guid("0b1f3cea-301a-4d74-9ce1-2cd93b41897d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "8",
+                            Order = 7,
+                            TypeId = 6,
+                            Value = "Августа"
+                        },
+                        new
+                        {
+                            Id = new Guid("e2fa3769-f66f-4753-a161-35adad7717a5"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "9",
+                            Order = 8,
+                            TypeId = 6,
+                            Value = "Сентября"
+                        },
+                        new
+                        {
+                            Id = new Guid("c1de4aca-9f49-48ae-9279-cf9ec4092112"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "10",
+                            Order = 9,
+                            TypeId = 6,
+                            Value = "Октября"
+                        },
+                        new
+                        {
+                            Id = new Guid("a74b9ebd-bcd8-4537-b371-194de2fe0a4d"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "11",
+                            Order = 10,
+                            TypeId = 6,
+                            Value = "Ноября"
+                        },
+                        new
+                        {
+                            Id = new Guid("852a5ebd-4545-494b-bc69-c27409a41adc"),
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppExportValue = "12",
+                            Order = 11,
+                            TypeId = 6,
+                            Value = "Декабря"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchValue", b =>
+                {
+                    b.Property<Guid>("JobGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TypeValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TypeConfigId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("JobGroupId", "TypeValueId", "TypeConfigId");
+
+                    b.HasIndex("TypeConfigId");
+
+                    b.HasIndex("TypeValueId");
+
+                    b.ToTable("EsppSchValues", "schedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ExcludeTypes", "schedule", t =>
+                        {
+                            t.HasComment("Расписание регламентной работы - Тип исключения");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("0595b8e0-f322-4661-b5e3-064af8fbe7cd"),
+                            Code = "None",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Нет исключений",
+                            EsppValue = "NONE",
+                            Title = "Нет исключений"
+                        },
+                        new
+                        {
+                            Id = new Guid("2b7a4356-9aaf-4e00-b444-42f0b5010e25"),
+                            Code = "Only",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Выполнить ТОЛЬКО В указанном календаре",
+                            EsppValue = "ONLY",
+                            Title = "Выполнить ТОЛЬКО В указанном календаре"
+                        },
+                        new
+                        {
+                            Id = new Guid("38cd9e64-27c1-4672-a805-2211952a48bd"),
+                            Code = "Except",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "Выполнить везде, КРОМЕ указанного календаря",
+                            EsppValue = "EXCEPT",
+                            Title = "Выполнить везде, КРОМЕ указанного календаря"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("EsppName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ExcludeTypeCalendars", "schedule", t =>
+                        {
+                            t.HasComment("Расписание регламентной работы, исключение - Календарь");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("a26edb88-0267-4fbf-b7ec-d172b0a86c9c"),
+                            Code = "24x5",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "24x5",
+                            EsppValue = "24x5",
+                            Title = "24x5"
+                        },
+                        new
+                        {
+                            Id = new Guid("6834f1d5-ac51-43d5-974e-4c759d7bbf9f"),
+                            Code = "24x7",
+                            DateCreated = new DateTimeOffset(new DateTime(2023, 5, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)),
+                            EsppName = "24x7",
+                            EsppValue = "24x7",
+                            Title = "24x7"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleResponseAreaTimeOffset", b =>
+                {
+                    b.Property<string>("ResponseArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppValue")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<TimeSpan>("UtcTimeOffset")
+                        .HasColumnType("interval");
+
+                    b.HasKey("ResponseArea");
+
+                    b.ToTable("ResponseAreaTimeOffsets", "schedule", t =>
+                        {
+                            t.HasComment("Расписание в ЕСПП. Смещение часового пояса относительно МСК для зоны ответственности рабочей группы");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Setting", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.ToTable("Settings");
+
+                    b.HasData(
+                        new
+                        {
+                            Name = "Initiator",
+                            Description = "Инициатор регламентной работы, указывается при создании шаблона в ЕСПП.",
+                            Value = "АКСЕНОВ АЛЕКСАНДР ЕВГЕНЬЕВИЧ (AKSENOVAE@GVC.OAO.RZD)"
+                        },
+                        new
+                        {
+                            Name = "ClosingCode",
+                            Description = "Код закрытия регламентной работы, указывается при создании шаблона в ЕСПП.",
+                            Value = "выполнен"
+                        },
+                        new
+                        {
+                            Name = "Category",
+                            Description = "Категория создаваемого объекта в ЕСПП",
+                            Value = "регламентная работа"
+                        },
+                        new
+                        {
+                            Name = "TemplatePrefixName",
+                            Description = "Префикс имени шаблона в ЕСПП",
+                            Value = "%PREFIX%-ЭИТИ-ПТК-ПАРР"
+                        },
+                        new
+                        {
+                            Name = "RobotAttemptsNumber",
+                            Description = "Количество попыток выполнения задания роботом",
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Name = "RobotWaitTime",
+                            Description = "Время ожидания выполнения роботом задания",
+                            Value = "00:10:00"
+                        },
+                        new
+                        {
+                            Name = "EsppScheduleTimezone",
+                            Description = "Расписание регламентной работы - В каком часовом поясе",
+                            Value = "MSK"
+                        },
+                        new
+                        {
+                            Name = "ScheduleRepeatRange",
+                            Description = "Расписание регламентной работы - Диапазн повторов",
+                            Value = "Отсутствует дата завершения"
+                        },
+                        new
+                        {
+                            Name = "OrderSearchDeltaDate",
+                            Description = "Промежуток времени для поиска нарядов в ЕСПП",
+                            Value = "01:30:00"
+                        },
+                        new
+                        {
+                            Name = "EsppRobotAccountTimeZoneHour",
+                            Description = "Таймзона УЗ роботов в ЕСПП, в часах (может быть положительная и отрицательная)",
+                            Value = "3"
+                        },
+                        new
+                        {
+                            Name = "WeekendCacheTtl",
+                            Description = "Время хранения в кэше данных о выходных и рабочих днях",
+                            Value = "01:00:00"
+                        },
+                        new
+                        {
+                            Name = "TemplateNameConstantParts",
+                            Description = "Список неизменных частей имени шаблона",
+                            Value = "[{\"Name\":\"П-1\",\"Value\":\"ЭИТИ-ПАРР\"}]"
+                        },
+                        new
+                        {
+                            Name = "EsppUnitTag",
+                            Description = "Префикс тега в поле ЭК \"Дополнительная информация\"",
+                            Value = "ПАРР_"
+                        },
+                        new
+                        {
+                            Name = "JobIdForUnusedTemplates",
+                            Description = "Job в который перемещаем ниспользованные шаблоны",
+                            Value = "8f85a91c-a223-4686-bb69-1f0ee73624f2"
+                        },
+                        new
+                        {
+                            Name = "DefaultResponseAreaToTimeOffset",
+                            Description = "Зона ответственности для получения тайм зоны по умолчанию для расписаний",
+                            Value = "17-МСК"
+                        },
+                        new
+                        {
+                            Name = "MinRelationshipsThresholdPct",
+                            Description = "Минимально допустимый процент связей для продолжения синхронизации. Защищает от удаления данных, если передающая система АИХ ИТ передала аномально малый объем связей. 0 — Защита ОТКЛЮЧЕНА, 100 — Строгий режим.",
+                            Value = "97"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ProcessId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EsppId")
+                        .IsUnique();
+
+                    b.HasIndex("ProcessId");
+
+                    b.ToTable("Subprocesses");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskError", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AttemptNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ErrorMessage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("StackTrace")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TaskId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId");
+
+                    b.ToTable("Errors", "task", t =>
+                        {
+                            t.HasComment("Таблица ошибок заданий");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("ProcessedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ProgressPercent")
+                        .HasColumnType("integer")
+                        .HasComment("Процент выполнения задачи");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("TypeCode")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StatusCode");
+
+                    b.HasIndex("TypeCode");
+
+                    b.ToTable("Tasks", "task", t =>
+                        {
+                            t.HasComment("Таблица заданий");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("Statuses", "task", t =>
+                        {
+                            t.HasComment("Таблица статусов заданий");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 0,
+                            Description = "Ожидание",
+                            Name = "Pending"
+                        },
+                        new
+                        {
+                            Code = 1,
+                            Description = "В работе",
+                            Name = "Processing"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "Выполнено успешно",
+                            Name = "Success"
+                        },
+                        new
+                        {
+                            Code = 3,
+                            Description = "Ошибка",
+                            Name = "Failed"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskType", b =>
+                {
+                    b.Property<int>("Code")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsSingleton")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MaxExecutionTimeMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RetentionDays")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("Types", "task", t =>
+                        {
+                            t.HasComment("Таблица типов заданий");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 0,
+                            Description = "Формирование данных для отчетности - Загруженность",
+                            IsSingleton = true,
+                            MaxExecutionTimeMinutes = 90,
+                            MaxRetries = 2,
+                            Name = "Workload",
+                            RetentionDays = 90
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("Index")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActiveSchedule")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActiveTemplate")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("JobId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("LastRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("NextRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ScheduleEsppId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JobId");
+
+                    b.HasIndex("StatusTypeId");
+
+                    b.HasIndex("UnitId");
+
+                    b.HasIndex("Name", "Index")
+                        .IsUnique();
+
+                    b.ToTable("Templates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateEntities.TemplateRenamePending", b =>
+                {
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("OldName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasComment("Старое имя шаблона");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("OldName")
+                        .IsUnique();
+
+                    b.ToTable("TemplateRenamePendings", "template", t =>
+                        {
+                            t.HasComment("Шаблоны находящиеся в процессе переименования");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateAddedToHistory")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("InitiatorComment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("InitiatorIp")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("InitiatorParrComponentId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsActiveSchedule")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActiveTemplate")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LastRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("NextRun")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("ParentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ScheduleEsppId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("StatusTypeId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("TemplateHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateStatusType", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TemplateStatusTypes", t =>
+                        {
+                            t.HasComment("Таблица описания критериев выборки аттрибутов ЭК");
+                        });
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 0,
+                            Description = "В работе",
+                            Name = "Used"
+                        },
+                        new
+                        {
+                            Id = 1,
+                            Description = "Не используется",
+                            Name = "Unused"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            Description = "Обновляется",
+                            Name = "Updating"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            Description = "Ошибка",
+                            Name = "Error"
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("EsppId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("SubprocessId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubprocessId");
+
+                    b.ToTable("Tnks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.Unit", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastLogon")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Units", "unit", t =>
+                        {
+                            t.HasComment("Таблица с ЭК");
+
+                            t.HasCheckConstraint("CK_Units_Name_Upper", "\"Name\" = UPPER(\"Name\") AND \"Name\" IS NOT NULL AND LENGTH(\"Name\")>0");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitField", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AihitName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Code")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EsppName")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("IsMultipleValue")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AihitName");
+
+                    b.HasIndex("EsppName");
+
+                    b.ToTable("Fields", "unit", t =>
+                        {
+                            t.HasComment("Справочник полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldInUnitFieldValue", b =>
+                {
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("FieldId", "FieldValueId");
+
+                    b.HasIndex("FieldValueId");
+
+                    b.ToTable("FieldInFieldValues", "unit", t =>
+                        {
+                            t.HasComment("Значения полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Value")
+                        .IsUnique();
+
+                    b.ToTable("FieldValues", "unit", t =>
+                        {
+                            t.HasComment("Значения полей ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInUnit", b =>
+                {
+                    b.Property<Guid>("ParentUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChildUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateSynced")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ParentUnitId", "ChildUnitId");
+
+                    b.HasIndex("ChildUnitId");
+
+                    b.ToTable("UnitInUnits", "unit", t =>
+                        {
+                            t.HasComment("Таблица связей иерархии между ЭК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInValue", b =>
+                {
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("FieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ValueId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("UnitId", "FieldId", "ValueId");
+
+                    b.HasIndex("ValueId");
+
+                    b.HasIndex("FieldId", "UnitId");
+
+                    b.HasIndex("FieldId", "ValueId");
+
+                    b.HasIndex("UnitId", "FieldId");
+
+                    b.ToTable("UnitInValues", "unit", t =>
+                        {
+                            t.HasComment("Таблица связи ЭК с полями и со значениями");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitKiiUnit", b =>
+                {
+                    b.Property<Guid>("UnitId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UnitId");
+
+                    b.ToTable("KiiUnits", "unit", t =>
+                        {
+                            t.HasComment("Таблица - Список ЭК КИИ, которые учавствуют в групповых работах. Создавалась как временная");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", b =>
+                {
+                    b.Property<Guid>("FieldValueId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("FieldValueId");
+
+                    b.ToTable("RegionalEkPtkGroups", "unit", t =>
+                        {
+                            t.HasComment("Таблица - региональные группы ПТК");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("LastLogon")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Ip")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.UsersInRole", b =>
+                {
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("RoleId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UsersInRoles");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.WeekendDay", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("date");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Date")
+                        .IsUnique();
+
+                    b.ToTable("WeekendDays", "schedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.AgentHistoryLevel", "AgentHistoryLevel")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("HistoryLevelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Order", "Order")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("OrderId");
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("AgentHistories")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("AgentHistoryLevel");
+
+                    b.Navigation("Order");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.DistributionPeriodType", "DistributionPeriodType")
+                        .WithMany("Periods")
+                        .HasForeignKey("Type")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DistributionPeriodType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "Group")
+                        .WithMany("Jobs")
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Tnk", "Tnk")
+                        .WithMany("Jobs")
+                        .HasForeignKey("TnkId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Group");
+
+                    b.Navigation("Tnk");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobAutoControl", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithOne("AutoControl")
+                        .HasForeignKey("PARR.Domain.Entities.JobEntities.JobAutoControl", "JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobFieldFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobFieldFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobEntities.JobUnitFilter", "UnitFilter")
+                        .WithMany("FieldFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobRelationshipFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobEntities.JobUnitFilter", "UnitFilter")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithMany("UnitFilters")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.UnitsInTemplate", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("UnitsInTemplate")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "UnitFieldValue")
+                        .WithMany("UnitsInTemplates")
+                        .HasForeignKey("UnitFieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("TemplatesInUnit")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+
+                    b.Navigation("Unit");
+
+                    b.Navigation("UnitFieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupType", "GroupType")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("GroupTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "GroupingUnitField")
+                        .WithMany("JobGroupWithGrouping")
+                        .HasForeignKey("GroupingUnitFieldId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", "ScheduleExcludeTypeCalendar")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("ScheduleExcludeTypeCalendarId");
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.ScheduleExcludeType", "ScheduleExcludeType")
+                        .WithMany("JobGroups")
+                        .HasForeignKey("ScheduleExcludeTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("GroupType");
+
+                    b.Navigation("GroupingUnitField");
+
+                    b.Navigation("ScheduleExcludeType");
+
+                    b.Navigation("ScheduleExcludeTypeCalendar");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithOne("AutoControl")
+                        .HasForeignKey("PARR.Domain.Entities.JobGroupEntities.JobGroupAutoControl", "JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.DistributionPeriod", "DistributionPeriod")
+                        .WithMany("GroupDistributionConfig")
+                        .HasForeignKey("DistributionPeriodId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "Group")
+                        .WithOne("DistributionConfig")
+                        .HasForeignKey("PARR.Domain.Entities.JobGroupEntities.JobGroupDistributionConfig", "GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DistributionPeriod");
+
+                    b.Navigation("Group");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupFieldFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobGroupFieldFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", "UnitFilter")
+                        .WithMany("FieldFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupRelationshipFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "UnitField")
+                        .WithMany("JobGroupRelationshipFilters")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", "UnitFilter")
+                        .WithMany("RelationshipFilters")
+                        .HasForeignKey("UnitFilterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("UnitField");
+
+                    b.Navigation("UnitFilter");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithMany()
+                        .HasForeignKey("JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.OrderStatus", "NextStatus")
+                        .WithMany("OrdersNext")
+                        .HasForeignKey("NextStatusCode");
+
+                    b.HasOne("PARR.Domain.Entities.OrderStatus", "OrderStatus")
+                        .WithMany("Orders")
+                        .HasForeignKey("StatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("Orders")
+                        .HasForeignKey("TemplateId");
+
+                    b.Navigation("NextStatus");
+
+                    b.Navigation("OrderStatus");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("RobotCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("RobotStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("RobotConfigurations")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Robot");
+
+                    b.Navigation("RobotStatus");
+
+                    b.Navigation("TaskStatus");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("RobotCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("RobotStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
+                        .WithMany("ConfigurationSnapshots")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Robot");
+
+                    b.Navigation("RobotStatus");
+
+                    b.Navigation("TaskStatus");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", "RobotHistoryLevel")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("HistoryLevel")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotConfiguration", "RobotConfiguration")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("RobotConfigurationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "StatusTask")
+                        .WithMany("RobotHistories")
+                        .HasForeignKey("TaskStatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RobotConfiguration");
+
+                    b.Navigation("RobotHistoryLevel");
+
+                    b.Navigation("StatusTask");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchType", "EsppSchType")
+                        .WithMany("EsppSchTypeConfigs")
+                        .HasForeignKey("TypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", "EsppSchTypeSchedule")
+                        .WithMany("EsppSchTypeConfigs")
+                        .HasForeignKey("TypeScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchType");
+
+                    b.Navigation("EsppSchTypeSchedule");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchType", "EsppSchType")
+                        .WithMany("EsppSchTypeValues")
+                        .HasForeignKey("TypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobGroupEntities.JobGroup", "JobGroup")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("JobGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", "EsppSchTypeConfig")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("TypeConfigId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Schedule.EsppSchTypeValue", "EsppSchTypeValue")
+                        .WithMany("EsppSchValues")
+                        .HasForeignKey("TypeValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EsppSchTypeConfig");
+
+                    b.Navigation("EsppSchTypeValue");
+
+                    b.Navigation("JobGroup");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Process", "Process")
+                        .WithMany("Subprocesses")
+                        .HasForeignKey("ProcessId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Process");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskError", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskItem", "TaskItem")
+                        .WithMany("TaskErrors")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TaskItem");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskStatus", "TaskStatus")
+                        .WithMany("Tasks")
+                        .HasForeignKey("StatusCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.TaskEntities.TaskType", "TaskType")
+                        .WithMany("Tasks")
+                        .HasForeignKey("TypeCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TaskStatus");
+
+                    b.Navigation("TaskType");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.JobEntities.Job", "Job")
+                        .WithMany("Templates")
+                        .HasForeignKey("JobId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.TemplateStatusType", "StatusType")
+                        .WithMany("Templates")
+                        .HasForeignKey("StatusTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("Templates")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Job");
+
+                    b.Navigation("StatusType");
+
+                    b.Navigation("Unit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateEntities.TemplateRenamePending", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithOne("TemplateRenamePending")
+                        .HasForeignKey("PARR.Domain.Entities.TemplateEntities.TemplateRenamePending", "TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithMany("TemplateHistories")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Subprocess", "Subprocess")
+                        .WithMany("Tnks")
+                        .HasForeignKey("SubprocessId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Subprocess");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldInUnitFieldValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "Field")
+                        .WithMany("UnitFieldValues")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "FieldValue")
+                        .WithMany("FieldValues")
+                        .HasForeignKey("FieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Field");
+
+                    b.Navigation("FieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInUnit", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "ChildUnit")
+                        .WithMany("ParentUnits")
+                        .HasForeignKey("ChildUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "ParentUnit")
+                        .WithMany("ChildUnits")
+                        .HasForeignKey("ParentUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("ChildUnit");
+
+                    b.Navigation("ParentUnit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitInValue", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitField", "Field")
+                        .WithMany("UnitInValues")
+                        .HasForeignKey("FieldId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithMany("UnitValues")
+                        .HasForeignKey("UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "Value")
+                        .WithMany("UnitInValues")
+                        .HasForeignKey("ValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Field");
+
+                    b.Navigation("Unit");
+
+                    b.Navigation("Value");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitKiiUnit", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.Unit", "Unit")
+                        .WithOne("UnitKii")
+                        .HasForeignKey("PARR.Domain.Entities.Unit.UnitKiiUnit", "UnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Unit");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Unit.UnitFieldValue", "FieldValue")
+                        .WithOne("RegionalEkPtkGroup")
+                        .HasForeignKey("PARR.Domain.Entities.Unit.UnitRegionalEkPtkGroup", "FieldValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("FieldValue");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.UsersInRole", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Role", "Role")
+                        .WithMany("Users")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PARR.Domain.Entities.User", "User")
+                        .WithMany("Roles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Role");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.AgentHistoryLevel", b =>
+                {
+                    b.Navigation("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriod", b =>
+                {
+                    b.Navigation("GroupDistributionConfig");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.DistributionPeriodType", b =>
+                {
+                    b.Navigation("Periods");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.Job", b =>
+                {
+                    b.Navigation("AutoControl");
+
+                    b.Navigation("Templates");
+
+                    b.Navigation("UnitFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobEntities.JobUnitFilter", b =>
+                {
+                    b.Navigation("FieldFilters");
+
+                    b.Navigation("RelationshipFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroup", b =>
+                {
+                    b.Navigation("AutoControl");
+
+                    b.Navigation("DistributionConfig");
+
+                    b.Navigation("EsppSchValues");
+
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupType", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.JobGroupEntities.JobGroupUnitFilter", b =>
+                {
+                    b.Navigation("FieldFilters");
+
+                    b.Navigation("RelationshipFilters");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Order", b =>
+                {
+                    b.Navigation("AgentHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.OrderStatus", b =>
+                {
+                    b.Navigation("Orders");
+
+                    b.Navigation("OrdersNext");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Process", b =>
+                {
+                    b.Navigation("Subprocesses");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
+                {
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
+                {
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
+                {
+                    b.Navigation("Users");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchType", b =>
+                {
+                    b.Navigation("EsppSchTypeConfigs");
+
+                    b.Navigation("EsppSchTypeValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeConfig", b =>
+                {
+                    b.Navigation("EsppSchValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeSchedule", b =>
+                {
+                    b.Navigation("EsppSchTypeConfigs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.EsppSchTypeValue", b =>
+                {
+                    b.Navigation("EsppSchValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeType", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Schedule.ScheduleExcludeTypeCalendar", b =>
+                {
+                    b.Navigation("JobGroups");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Subprocess", b =>
+                {
+                    b.Navigation("Tnks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskItem", b =>
+                {
+                    b.Navigation("TaskErrors");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskStatus", b =>
+                {
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TaskEntities.TaskType", b =>
+                {
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
+                {
+                    b.Navigation("AgentHistories");
+
+                    b.Navigation("Orders");
+
+                    b.Navigation("RobotConfigurations");
+
+                    b.Navigation("TemplateHistories");
+
+                    b.Navigation("TemplateRenamePending");
+
+                    b.Navigation("UnitsInTemplate");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateStatusType", b =>
+                {
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Tnk", b =>
+                {
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.Unit", b =>
+                {
+                    b.Navigation("ChildUnits");
+
+                    b.Navigation("ParentUnits");
+
+                    b.Navigation("Templates");
+
+                    b.Navigation("TemplatesInUnit");
+
+                    b.Navigation("UnitKii");
+
+                    b.Navigation("UnitValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitField", b =>
+                {
+                    b.Navigation("JobFieldFilters");
+
+                    b.Navigation("JobGroupFieldFilters");
+
+                    b.Navigation("JobGroupRelationshipFilters");
+
+                    b.Navigation("JobGroupWithGrouping");
+
+                    b.Navigation("RelationshipFilters");
+
+                    b.Navigation("UnitFieldValues");
+
+                    b.Navigation("UnitInValues");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.Unit.UnitFieldValue", b =>
+                {
+                    b.Navigation("FieldValues");
+
+                    b.Navigation("RegionalEkPtkGroup");
+
+                    b.Navigation("UnitInValues");
+
+                    b.Navigation("UnitsInTemplates");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.User", b =>
+                {
+                    b.Navigation("Roles");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.cs b/PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.cs
new file mode 100644
index 00000000..0dba9728
--- /dev/null
+++ b/PARR.DAL/Migrations/20260721013444_tblTemplateRenamePendings.cs
@@ -0,0 +1,54 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PARR.DAL.Migrations
+{
+    /// <inheritdoc />
+    public partial class tblTemplateRenamePendings : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "template");
+
+            migrationBuilder.CreateTable(
+                name: "TemplateRenamePendings",
+                schema: "template",
+                columns: table => new
+                {
+                    TemplateId = table.Column<Guid>(type: "uuid", nullable: false),
+                    DateCreated = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    OldName = table.Column<string>(type: "text", nullable: false, comment: "Старое имя шаблона")
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TemplateRenamePendings", x => x.TemplateId);
+                    table.ForeignKey(
+                        name: "FK_TemplateRenamePendings_Templates_TemplateId",
+                        column: x => x.TemplateId,
+                        principalTable: "Templates",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                },
+                comment: "Шаблоны находящиеся в процессе переименования");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TemplateRenamePendings_OldName",
+                schema: "template",
+                table: "TemplateRenamePendings",
+                column: "OldName",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "TemplateRenamePendings",
+                schema: "template");
+        }
+    }
+}
diff --git a/PARR.DAL/Migrations/DataContextModelSnapshot.cs b/PARR.DAL/Migrations/DataContextModelSnapshot.cs
index 6584df27..83464595 100644
--- a/PARR.DAL/Migrations/DataContextModelSnapshot.cs
+++ b/PARR.DAL/Migrations/DataContextModelSnapshot.cs
@@ -921,44 +921,6 @@ namespace PARR.DAL.Migrations
                     b.ToTable("Processes");
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.Robot", b =>
-                {
-                    b.Property<int>("Code")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Code");
-
-                    b.HasIndex("Name")
-                        .IsUnique();
-
-                    b.ToTable("Robots");
-
-                    b.HasData(
-                        new
-                        {
-                            Code = 1,
-                            Description = "Робот по созданию/изменению шаблона наряда ЕСПП",
-                            Name = "TemplateOrder"
-                        },
-                        new
-                        {
-                            Code = 2,
-                            Description = "Робот по созданию/изменению расписания шаблона наряда в ЕСПП",
-                            Name = "ScheduleOrder"
-                        });
-                });
-
             modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
                 {
                     b.Property<Guid>("Id")
@@ -1004,6 +966,44 @@ namespace PARR.DAL.Migrations
                     b.ToTable("RobotConfigurations");
                 });
 
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Robots", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 1,
+                            Description = "Робот по созданию/изменению шаблона наряда ЕСПП",
+                            Name = "TemplateOrder"
+                        },
+                        new
+                        {
+                            Code = 2,
+                            Description = "Робот по созданию/изменению расписания шаблона наряда в ЕСПП",
+                            Name = "ScheduleOrder"
+                        });
+                });
+
             modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
                 {
                     b.Property<Guid>("Id")
@@ -1040,44 +1040,7 @@ namespace PARR.DAL.Migrations
                         });
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotSnapshot", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTimeOffset>("DateCreated")
-                        .HasColumnType("timestamp with time zone");
-
-                    b.Property<string>("Ip")
-                        .IsRequired()
-                        .HasMaxLength(45)
-                        .HasColumnType("character varying(45)")
-                        .HasComment("Текущий IP-адрес сервера");
-
-                    b.Property<int>("MaxRobots")
-                        .HasColumnType("integer")
-                        .HasComment("Максимально разрешенное количество роботов на сервере");
-
-                    b.Property<int>("ScheduleRobotsCount")
-                        .HasColumnType("integer")
-                        .HasComment("Количество запущенных роботов по расписаниям");
-
-                    b.Property<int>("TemplateRobotsCount")
-                        .HasColumnType("integer")
-                        .HasComment("Количество запущенных роботов по шаблонам");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("Ip", "DateCreated");
-
-                    b.ToTable("Snapshots", "robot", t =>
-                        {
-                            t.HasComment("Снимки роботов");
-                        });
-                });
-
-            modelBuilder.Entity("PARR.Domain.Entities.RobotHistory", b =>
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
                 {
                     b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
@@ -1119,10 +1082,10 @@ namespace PARR.DAL.Migrations
 
                     b.HasIndex("RobotConfigurationId", "DateCreated");
 
-                    b.ToTable("RobotHistories");
+                    b.ToTable("Histories", "robot");
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.RobotHistoryLevel", b =>
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
                 {
                     b.Property<int>("Level")
                         .ValueGeneratedOnAdd()
@@ -1140,7 +1103,7 @@ namespace PARR.DAL.Migrations
 
                     b.HasKey("Level");
 
-                    b.ToTable("RobotHistoryLevels");
+                    b.ToTable("HistoryLevels", "robot");
 
                     b.HasData(
                         new
@@ -1169,7 +1132,44 @@ namespace PARR.DAL.Migrations
                         });
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.RobotStatus", b =>
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotSnapshot", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ip")
+                        .IsRequired()
+                        .HasMaxLength(45)
+                        .HasColumnType("character varying(45)")
+                        .HasComment("Текущий IP-адрес сервера");
+
+                    b.Property<int>("MaxRobots")
+                        .HasColumnType("integer")
+                        .HasComment("Максимально разрешенное количество роботов на сервере");
+
+                    b.Property<int>("ScheduleRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по расписаниям");
+
+                    b.Property<int>("TemplateRobotsCount")
+                        .HasColumnType("integer")
+                        .HasComment("Количество запущенных роботов по шаблонам");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Ip", "DateCreated");
+
+                    b.ToTable("Snapshots", "robot", t =>
+                        {
+                            t.HasComment("Снимки роботов");
+                        });
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
                 {
                     b.Property<int>("Code")
                         .ValueGeneratedOnAdd()
@@ -1187,7 +1187,7 @@ namespace PARR.DAL.Migrations
 
                     b.HasKey("Code");
 
-                    b.ToTable("RobotStatuses");
+                    b.ToTable("RobotStatuses", "robot");
 
                     b.HasData(
                         new
@@ -1216,6 +1216,47 @@ namespace PARR.DAL.Migrations
                         });
                 });
 
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Property<int>("Code")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("TaskStatuses", "robot");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = 10,
+                            Description = "Требуется создание объекта в ЕСПП",
+                            Name = "Creating"
+                        },
+                        new
+                        {
+                            Code = 20,
+                            Description = "Требуется обновление объекта в ЕСПП",
+                            Name = "Updating"
+                        },
+                        new
+                        {
+                            Code = 30,
+                            Description = "Нормальное состояние объекта в ЕСПП и ПАРР. Объект в ПАРР соответствует объекту в ЕСПП",
+                            Name = "Ok"
+                        });
+                });
+
             modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
                 {
                     b.Property<Guid>("Id")
@@ -2743,47 +2784,6 @@ namespace PARR.DAL.Migrations
                         });
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.TaskStatus", b =>
-                {
-                    b.Property<int>("Code")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("integer");
-
-                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Code"));
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Code");
-
-                    b.ToTable("TaskStatuses");
-
-                    b.HasData(
-                        new
-                        {
-                            Code = 10,
-                            Description = "Требуется создание объекта в ЕСПП",
-                            Name = "Creating"
-                        },
-                        new
-                        {
-                            Code = 20,
-                            Description = "Требуется обновление объекта в ЕСПП",
-                            Name = "Updating"
-                        },
-                        new
-                        {
-                            Code = 30,
-                            Description = "Нормальное состояние объекта в ЕСПП и ПАРР. Объект в ПАРР соответствует объекту в ЕСПП",
-                            Name = "Ok"
-                        });
-                });
-
             modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
                 {
                     b.Property<Guid>("Id")
@@ -2850,6 +2850,30 @@ namespace PARR.DAL.Migrations
                     b.ToTable("Templates");
                 });
 
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateEntities.TemplateRenamePending", b =>
+                {
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("OldName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasComment("Старое имя шаблона");
+
+                    b.HasKey("TemplateId");
+
+                    b.HasIndex("OldName")
+                        .IsUnique();
+
+                    b.ToTable("TemplateRenamePendings", "template", t =>
+                        {
+                            t.HasComment("Шаблоны находящиеся в процессе переименования");
+                        });
+                });
+
             modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
                 {
                     b.Property<Guid>("Id")
@@ -3516,19 +3540,19 @@ namespace PARR.DAL.Migrations
 
             modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
                 {
-                    b.HasOne("PARR.Domain.Entities.Robot", "Robot")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
                         .WithMany("RobotConfigurations")
                         .HasForeignKey("RobotCode")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("PARR.Domain.Entities.RobotStatus", "RobotStatus")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
                         .WithMany("RobotConfigurations")
                         .HasForeignKey("RobotStatusCode")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("PARR.Domain.Entities.TaskStatus", "TaskStatus")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
                         .WithMany("RobotConfigurations")
                         .HasForeignKey("TaskStatusCode")
                         .OnDelete(DeleteBehavior.Cascade)
@@ -3551,19 +3575,19 @@ namespace PARR.DAL.Migrations
 
             modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotConfigurationSnapshot", b =>
                 {
-                    b.HasOne("PARR.Domain.Entities.Robot", "Robot")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.Robot", "Robot")
                         .WithMany("ConfigurationSnapshots")
                         .HasForeignKey("RobotCode")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("PARR.Domain.Entities.RobotStatus", "RobotStatus")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotStatus", "RobotStatus")
                         .WithMany("ConfigurationSnapshots")
                         .HasForeignKey("RobotStatusCode")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("PARR.Domain.Entities.TaskStatus", "TaskStatus")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "TaskStatus")
                         .WithMany("ConfigurationSnapshots")
                         .HasForeignKey("TaskStatusCode")
                         .OnDelete(DeleteBehavior.Cascade)
@@ -3576,9 +3600,9 @@ namespace PARR.DAL.Migrations
                     b.Navigation("TaskStatus");
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.RobotHistory", b =>
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistory", b =>
                 {
-                    b.HasOne("PARR.Domain.Entities.RobotHistoryLevel", "RobotHistoryLevel")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", "RobotHistoryLevel")
                         .WithMany("RobotHistories")
                         .HasForeignKey("HistoryLevel")
                         .OnDelete(DeleteBehavior.Cascade)
@@ -3590,7 +3614,7 @@ namespace PARR.DAL.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
-                    b.HasOne("PARR.Domain.Entities.TaskStatus", "StatusTask")
+                    b.HasOne("PARR.Domain.Entities.RobotEntities.TaskStatus", "StatusTask")
                         .WithMany("RobotHistories")
                         .HasForeignKey("TaskStatusCode")
                         .OnDelete(DeleteBehavior.Cascade)
@@ -3728,6 +3752,17 @@ namespace PARR.DAL.Migrations
                     b.Navigation("Unit");
                 });
 
+            modelBuilder.Entity("PARR.Domain.Entities.TemplateEntities.TemplateRenamePending", b =>
+                {
+                    b.HasOne("PARR.Domain.Entities.Template", "Template")
+                        .WithOne("TemplateRenamePending")
+                        .HasForeignKey("PARR.Domain.Entities.TemplateEntities.TemplateRenamePending", "TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Template");
+                });
+
             modelBuilder.Entity("PARR.Domain.Entities.TemplateHistory", b =>
                 {
                     b.HasOne("PARR.Domain.Entities.Template", "Template")
@@ -3927,30 +3962,39 @@ namespace PARR.DAL.Migrations
                     b.Navigation("Subprocesses");
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.Robot", b =>
-                {
-                    b.Navigation("ConfigurationSnapshots");
-
-                    b.Navigation("RobotConfigurations");
-                });
-
             modelBuilder.Entity("PARR.Domain.Entities.RobotConfiguration", b =>
                 {
                     b.Navigation("RobotHistories");
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.RobotHistoryLevel", b =>
-                {
-                    b.Navigation("RobotHistories");
-                });
-
-            modelBuilder.Entity("PARR.Domain.Entities.RobotStatus", b =>
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.Robot", b =>
                 {
                     b.Navigation("ConfigurationSnapshots");
 
                     b.Navigation("RobotConfigurations");
                 });
 
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotHistoryLevel", b =>
+                {
+                    b.Navigation("RobotHistories");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.RobotStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+                });
+
+            modelBuilder.Entity("PARR.Domain.Entities.RobotEntities.TaskStatus", b =>
+                {
+                    b.Navigation("ConfigurationSnapshots");
+
+                    b.Navigation("RobotConfigurations");
+
+                    b.Navigation("RobotHistories");
+                });
+
             modelBuilder.Entity("PARR.Domain.Entities.Role", b =>
                 {
                     b.Navigation("Users");
@@ -4008,15 +4052,6 @@ namespace PARR.DAL.Migrations
                     b.Navigation("Tasks");
                 });
 
-            modelBuilder.Entity("PARR.Domain.Entities.TaskStatus", b =>
-                {
-                    b.Navigation("ConfigurationSnapshots");
-
-                    b.Navigation("RobotConfigurations");
-
-                    b.Navigation("RobotHistories");
-                });
-
             modelBuilder.Entity("PARR.Domain.Entities.Template", b =>
                 {
                     b.Navigation("AgentHistories");
@@ -4027,6 +4062,8 @@ namespace PARR.DAL.Migrations
 
                     b.Navigation("TemplateHistories");
 
+                    b.Navigation("TemplateRenamePending");
+
                     b.Navigation("UnitsInTemplate");
                 });
 
diff --git a/PARR.DAL/Repositories/RobotHistoryLevelRepository.cs b/PARR.DAL/Repositories/RobotHistoryLevelRepository.cs
index 88631d02..afea79b1 100644
--- a/PARR.DAL/Repositories/RobotHistoryLevelRepository.cs
+++ b/PARR.DAL/Repositories/RobotHistoryLevelRepository.cs
@@ -1,6 +1,6 @@
 using PARR.Core.Repositories.Interfaces;
 using PARR.DAL.Context;
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.DAL.Repositories
 {
diff --git a/PARR.DAL/Repositories/RobotHistoryRepository.cs b/PARR.DAL/Repositories/RobotHistoryRepository.cs
index 73e51843..8dc658dc 100644
--- a/PARR.DAL/Repositories/RobotHistoryRepository.cs
+++ b/PARR.DAL/Repositories/RobotHistoryRepository.cs
@@ -2,7 +2,7 @@
 using PARR.Core.Repositories.Interfaces;
 using PARR.DAL.Context;
 using PARR.DAL.Repositories.Base;
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.DAL.Repositories
 {
diff --git a/PARR.DAL/Repositories/RobotRepository.cs b/PARR.DAL/Repositories/RobotRepository.cs
index ec23e343..529f24df 100644
--- a/PARR.DAL/Repositories/RobotRepository.cs
+++ b/PARR.DAL/Repositories/RobotRepository.cs
@@ -1,6 +1,6 @@
 using PARR.Core.Repositories.Interfaces;
 using PARR.DAL.Context;
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.DAL.Repositories
 {
diff --git a/PARR.DAL/Repositories/RobotStatusRepository.cs b/PARR.DAL/Repositories/RobotStatusRepository.cs
index 49dbc4d9..0bb217d7 100644
--- a/PARR.DAL/Repositories/RobotStatusRepository.cs
+++ b/PARR.DAL/Repositories/RobotStatusRepository.cs
@@ -1,6 +1,6 @@
 using PARR.Core.Repositories.Interfaces;
 using PARR.DAL.Context;
-using PARR.Domain.Entities;
+using PARR.Domain.Entities.RobotEntities;
 
 namespace PARR.DAL.Repositories
 {
diff --git a/PARR.DAL/Repositories/StatusTemplateRepository.cs b/PARR.DAL/Repositories/StatusTemplateRepository.cs
index 413361c0..6000b62f 100644
--- a/PARR.DAL/Repositories/StatusTemplateRepository.cs
+++ b/PARR.DAL/Repositories/StatusTemplateRepository.cs
@@ -12,7 +12,7 @@ namespace PARR.DAL.Repositories
             this.dataContext = dataContext;
         }
 
-        public IQueryable<Domain.Entities.TaskStatus> Get()
+        public IQueryable<Domain.Entities.RobotEntities.TaskStatus> Get()
         {
             return dataContext.TaskStatuses;
         }
diff --git a/PARR.DAL/Repositories/TaskStatusRepository.cs b/PARR.DAL/Repositories/TaskStatusRepository.cs
index dc8698f4..058f4098 100644
--- a/PARR.DAL/Repositories/TaskStatusRepository.cs
+++ b/PARR.DAL/Repositories/TaskStatusRepository.cs
@@ -12,7 +12,7 @@ namespace PARR.DAL.Repositories
             this.dataContext = dataContext;
         }
 
-        public IQueryable<Domain.Entities.TaskStatus> Get()
+        public IQueryable<Domain.Entities.RobotEntities.TaskStatus> Get()
         {
             return dataContext.TaskStatuses;
         }
diff --git a/PARR.Domain/Constants/DatabaseSchemas.cs b/PARR.Domain/Constants/DatabaseSchemas.cs
index 31df4bc6..2abb95fd 100644
--- a/PARR.Domain/Constants/DatabaseSchemas.cs
+++ b/PARR.Domain/Constants/DatabaseSchemas.cs
@@ -32,10 +32,19 @@
         /// </summary>
         public const string Task = "task";
 
-
         /// <summary>
         /// Робот
         /// </summary>
         public const string Robot = "robot";
+
+        /// <summary>
+        /// Шаблоны
+        /// </summary>
+        public const string Template = "template";
+
+        /// <summary>
+        /// Схема public
+        /// </summary>
+        public const string Public = "public";
     }
 }
diff --git a/PARR.Domain/Entities/RobotConfiguration.cs b/PARR.Domain/Entities/RobotConfiguration.cs
index a65b0ec2..aaacbf0a 100644
--- a/PARR.Domain/Entities/RobotConfiguration.cs
+++ b/PARR.Domain/Entities/RobotConfiguration.cs
@@ -1,5 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using PARR.Domain.Entities.Base;
+using PARR.Domain.Entities.RobotEntities;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
@@ -53,7 +54,7 @@ namespace PARR.Domain.Entities
         public Robot? Robot { get; set; }
 
         [ForeignKey(nameof(TaskStatusCode))]
-        public TaskStatus? TaskStatus { get; set; }
+        public RobotEntities.TaskStatus? TaskStatus { get; set; }
 
         [ForeignKey(nameof(RobotStatusCode))]
         public RobotStatus? RobotStatus { get; set; }
diff --git a/PARR.Domain/Entities/Robot.cs b/PARR.Domain/Entities/RobotEntities/Robot.cs
similarity index 83%
rename from PARR.Domain/Entities/Robot.cs
rename to PARR.Domain/Entities/RobotEntities/Robot.cs
index 20c98ede..cb5cbe7c 100644
--- a/PARR.Domain/Entities/Robot.cs
+++ b/PARR.Domain/Entities/RobotEntities/Robot.cs
@@ -1,11 +1,11 @@
 using Microsoft.EntityFrameworkCore;
-using PARR.Domain.Entities.RobotEntities;
+using PARR.Domain.Constants;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace PARR.Domain.Entities
+namespace PARR.Domain.Entities.RobotEntities
 {
-    [Table("Robots")]
+    [Table("Robots", Schema = DatabaseSchemas.Robot)]
     [Index(nameof(Name), IsUnique = true)]
     public class Robot
     {
diff --git a/PARR.Domain/Entities/RobotHistory.cs b/PARR.Domain/Entities/RobotEntities/RobotHistory.cs
similarity index 90%
rename from PARR.Domain/Entities/RobotHistory.cs
rename to PARR.Domain/Entities/RobotEntities/RobotHistory.cs
index 7a4d4951..87f03076 100644
--- a/PARR.Domain/Entities/RobotHistory.cs
+++ b/PARR.Domain/Entities/RobotEntities/RobotHistory.cs
@@ -1,10 +1,12 @@
 using Microsoft.EntityFrameworkCore;
+using PARR.Domain.Constants;
 using PARR.Domain.Entities.Base;
 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace PARR.Domain.Entities
+namespace PARR.Domain.Entities.RobotEntities
 {
-    [Table("RobotHistories")]
+    //[Table("RobotHistories", Schema = DatabaseSchemas.Robot)]
+    [Table("Histories", Schema = DatabaseSchemas.Robot)]
     [Index(nameof(HistoryLevel), nameof(DateCreated), IsDescending = new[] { false, true })]
     [Index(nameof(RobotConfigurationId), nameof(DateCreated))]
     [Index(nameof(DateCreated))]
diff --git a/PARR.Domain/Entities/RobotHistoryLevel.cs b/PARR.Domain/Entities/RobotEntities/RobotHistoryLevel.cs
similarity index 64%
rename from PARR.Domain/Entities/RobotHistoryLevel.cs
rename to PARR.Domain/Entities/RobotEntities/RobotHistoryLevel.cs
index 446a7e2a..8817017b 100644
--- a/PARR.Domain/Entities/RobotHistoryLevel.cs
+++ b/PARR.Domain/Entities/RobotEntities/RobotHistoryLevel.cs
@@ -1,12 +1,14 @@
-using System.ComponentModel.DataAnnotations;
+using PARR.Domain.Constants;
+using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace PARR.Domain.Entities
+namespace PARR.Domain.Entities.RobotEntities
 {
     /// <summary>
     /// Уровень логов работы робота
     /// </summary>
-    [Table("RobotHistoryLevels")]
+    //[Table("RobotHistoryLevels", Schema = DatabaseSchemas.Robot)]
+    [Table("HistoryLevels", Schema = DatabaseSchemas.Robot)]
     public class RobotHistoryLevel
     {
         [Key]
@@ -18,8 +20,5 @@ namespace PARR.Domain.Entities
 
 
         public ICollection<RobotHistory> RobotHistories { get; set; } = new HashSet<RobotHistory>();
-
-
-
     }
 }
diff --git a/PARR.Domain/Entities/RobotStatus.cs b/PARR.Domain/Entities/RobotEntities/RobotStatus.cs
similarity index 83%
rename from PARR.Domain/Entities/RobotStatus.cs
rename to PARR.Domain/Entities/RobotEntities/RobotStatus.cs
index 2974f79b..a14f7617 100644
--- a/PARR.Domain/Entities/RobotStatus.cs
+++ b/PARR.Domain/Entities/RobotEntities/RobotStatus.cs
@@ -1,13 +1,13 @@
-using PARR.Domain.Entities.RobotEntities;
+using PARR.Domain.Constants;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace PARR.Domain.Entities
+namespace PARR.Domain.Entities.RobotEntities
 {
     /// <summary>
     /// Статус работы робота
     /// </summary>
-    [Table("RobotStatuses")]
+    [Table("RobotStatuses", Schema = DatabaseSchemas.Robot)]
     public class RobotStatus
     {
         [Key]
diff --git a/PARR.Domain/Entities/TaskStatus.cs b/PARR.Domain/Entities/RobotEntities/TaskStatus.cs
similarity index 86%
rename from PARR.Domain/Entities/TaskStatus.cs
rename to PARR.Domain/Entities/RobotEntities/TaskStatus.cs
index 62b32818..76c81033 100644
--- a/PARR.Domain/Entities/TaskStatus.cs
+++ b/PARR.Domain/Entities/RobotEntities/TaskStatus.cs
@@ -1,13 +1,13 @@
-using PARR.Domain.Entities.RobotEntities;
+using PARR.Domain.Constants;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace PARR.Domain.Entities
+namespace PARR.Domain.Entities.RobotEntities
 {
     /// <summary>
     /// Статус шаблона. Что нужно сделать роботу в ЕСПП
     /// </summary>
-    [Table("TaskStatuses")]
+    [Table("TaskStatuses", Schema = DatabaseSchemas.Robot)]
     public class TaskStatus
     {
         [Key]
diff --git a/PARR.Domain/Entities/Template.cs b/PARR.Domain/Entities/Template.cs
index bc3c8eb8..c1ff3c74 100644
--- a/PARR.Domain/Entities/Template.cs
+++ b/PARR.Domain/Entities/Template.cs
@@ -3,6 +3,7 @@ using PARR.Domain.Entities.Base;
 using PARR.Domain.Entities.Base.History;
 using PARR.Domain.Entities.Base.History.Base;
 using PARR.Domain.Entities.JobEntities;
+using PARR.Domain.Entities.TemplateEntities;
 using PARR.Domain.Enums;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
@@ -94,5 +95,7 @@ namespace PARR.Domain.Entities
         public ICollection<UnitsInTemplate> UnitsInTemplate { get; set; } = new HashSet<UnitsInTemplate>();
 
         public TemplateStatusType? StatusType { get; set; }
+
+        public TemplateRenamePending? TemplateRenamePending { get; set; }
     }
 }
diff --git a/PARR.Domain/Entities/TemplateEntities/TemplateRenamePending.cs b/PARR.Domain/Entities/TemplateEntities/TemplateRenamePending.cs
new file mode 100644
index 00000000..f534ee61
--- /dev/null
+++ b/PARR.Domain/Entities/TemplateEntities/TemplateRenamePending.cs
@@ -0,0 +1,31 @@
+using Microsoft.EntityFrameworkCore;
+using PARR.Domain.Constants;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace PARR.Domain.Entities.TemplateEntities
+{
+    /// <summary>
+    /// Шаблоны находящиеся в процессе переименования
+    /// </summary>
+    [Table("TemplateRenamePendings", Schema = DatabaseSchemas.Template)]
+    [Comment("Шаблоны находящиеся в процессе переименования")]
+    [Index(nameof(OldName), IsUnique = true)]
+    public class TemplateRenamePending
+    {
+        [Key]
+        public Guid TemplateId { get; set; }
+
+        public DateTimeOffset DateCreated { get; set; }
+
+        /// <summary>
+        /// Старое имя шаблона
+        /// </summary>
+        [Comment("Старое имя шаблона")]
+        public required string OldName { get; set; }
+
+
+        [ForeignKey(nameof(TemplateId))]
+        public required Template Template { get; set; }
+    }
+}