Merge branch 'template-generator-worker' into dev

.gitlab-ci.yml

@@ -13,6 +13,7 @@ variables:
   PROD_NAME_NEXT_RUN: "parr/parr-next-run"
   PROD_TEMPLATE_DISTRIBOTOR: "parr/parr-template-distributor"
   PROD_TEMPLATE_ACTIVATOR: "parr/parr-template-activator"
+  PROD_TEMPLATE_GENERATOR: "parr/parr-template-generator"
   PROD_JOB_AUTO_CONTROL: "parr/parr-job-auto-control"
 
 stages:
@@ -659,6 +660,54 @@ prod_template_activator_deploy:
     - ${RUNNER}
 
 
+### TEMPLATE GENERATOR PROD ###
+prod_template_generator_build:
+  stage: build
+  only:
+    - /^tg[0-9]+\.[0-9]+\.[0-9]+$/
+  except:
+    - branches
+  services:
+    - name: docker:20.10.21-dind
+      command: [
+        "--insecure-registry=10.99.253.167:8090",
+        "--registry-mirror=http://10.99.253.167:8090",
+        "--insecure-registry=harbor.dvgd.rzd",
+        "--tls=false"
+        ]
+  variables:
+    DOCKER_HOST: tcp://docker:2375
+    DOCKER_DRIVER: overlay2
+    DOCKER_TLS_CERTDIR: ""
+  script:
+    - APP_VERSION=$(echo $CI_COMMIT_TAG | tr -d tg)
+    - IMAGE_VERSION=$(echo $CI_COMMIT_TAG | sed 's/tg/v/g')
+    - docker build -t $REPO/$PROD_TEMPLATE_GENERATOR:$IMAGE_VERSION -t $REPO/$PROD_TEMPLATE_GENERATORR:latest -t $PROD_TEMPLATE_GENERATOR:$IMAGE_VERSION -t $PROD_TEMPLATE_GENERATOR:latest --build-arg app_version=$APP_VERSION -f PARR.TemplateGeneratorWorker/Dockerfile .
+    - docker login -u $HARBOR_PUSH_USER -p $HARBOR_PUSH_PASS $REPO
+    - docker push --all-tags $REPO/$PROD_TEMPLATE_GENERATOR
+  tags:
+    - docker
+
+
+prod_template_generator_deploy:
+  stage: deploy
+  environment:
+    name: parr-template-generator
+  only:
+    - /^tg[0-9]+\.[0-9]+\.[0-9]+$/
+  except:
+    - branches
+  script:
+    - IMAGE_VERSION=$(echo $CI_COMMIT_TAG | sed 's/tg/v/g')
+    - docker login -u $HARBOR_PULL_USER -p $HARBOR_PULL_PASS $REPO 
+    - tag=$IMAGE_VERSION docker stack deploy -c docker-compose.template-generator.yml parr-template-generator --with-registry-auth
+  parallel:
+    matrix:
+      - RUNNER: shell-api-swarm-01
+  tags:
+    - ${RUNNER}
+
+
 ### JOB AUTO CONTROL PROD ###
 prod_job_auto_control_build:
   stage: build

PARR.API.sln

@@ -90,6 +90,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PARR.AIHITRelationshipsSync
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PARR.AIHITRelationshipsSyncerWorker", "PARR.AIHITRelationshipsSyncerWorker\PARR.AIHITRelationshipsSyncerWorker.csproj", "{64010D07-4053-4EA9-B0F0-E773B5749DBD}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PARR.TemplateGeneratorWorker", "PARR.TemplateGeneratorWorker\PARR.TemplateGeneratorWorker.csproj", "{17245D0B-3290-4C96-B5B1-4B0711BABAF2}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -250,6 +252,10 @@ Global
 		{64010D07-4053-4EA9-B0F0-E773B5749DBD}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{64010D07-4053-4EA9-B0F0-E773B5749DBD}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{64010D07-4053-4EA9-B0F0-E773B5749DBD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{17245D0B-3290-4C96-B5B1-4B0711BABAF2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{17245D0B-3290-4C96-B5B1-4B0711BABAF2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{17245D0B-3290-4C96-B5B1-4B0711BABAF2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{17245D0B-3290-4C96-B5B1-4B0711BABAF2}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

PARR.BLL/Domain/Mq/TemplateGeneratorWorkerMq.cs

@@ -0,0 +1,36 @@
+using PARR.Common.Domain;
+
+namespace PARR.BLL.Domain.Mq
+{
+    /// <summary>
+    /// Модель в MQ, простого создания Template
+    /// </summary>
+    public class TemplateGeneratorWorkerMq
+    {
+        /// <summary>
+        /// Id регламентной работы
+        /// </summary>
+        public Guid JobId { get; set; }
+
+        /// <summary>
+        /// Id Юнита(единицы обслуживания)/ЭК
+        /// </summary>
+        public Guid UnitId { get; set; }
+
+        /// <summary>
+        /// Актировать шаблон при инициализации
+        /// </summary>
+        public bool? IsActiveTemplate { get; set; }
+
+        /// <summary>
+        /// Актировать расписание при инициализации
+        /// </summary>
+        public bool? IsActiveSchedule { get; set; }
+
+        /// <summary>
+        /// Инициатор запроса к генератору
+        /// </summary>
+        public HistoryInitiator? HistoryInitiator { get; set; }
+
+    }
+}

PARR.Constants/ParrComponentsEnum.cs

@@ -71,6 +71,11 @@
         /// <summary>
         /// Автораспределение РР
         /// </summary>
-        TemplateDistributor = 12
+        TemplateDistributor = 12,
+
+        /// <summary>
+        /// Генератор Template
+        /// </summary>
+        TemplateGenerator = 13
     }
 }

PARR.DAL/DomainServices/Implementations/UnitFilterService.cs

@@ -66,8 +66,6 @@ namespace PARR.DAL.DomainServices.Implementations
                                     .ThenInclude(t => t.UnitValues)
                                         .ThenInclude(t => t.Value);
 
-            logger.LogInformation($"В baseQuery записей {await baseQuery.CountAsync()}");
-
             foreach (var unitFilter in job.UnitFilters)
             {
                 var query = baseQuery.Where(t => EF.Functions.ILike(t.Name, unitFilter.UnitFilter));
@@ -94,7 +92,6 @@ namespace PARR.DAL.DomainServices.Implementations
                             else
                                 query = query.Where(t => !t.ParentUnits.Any() || !t.ParentUnits.Any(p => p.ParentUnit!.UnitValues.Any(pf => pf.FieldId == parentFilter.FieldId && (pf.Value!.Value != null && EF.Functions.ILike(pf.Value.Value, parentFilter.ValueMask)))));
                         }
-                        logger.LogInformation($"!В query записей {await query.CountAsync()}");
                     }
                 }
                 var newUnits = await query.Select(t => t.Id).ToListAsync();

PARR.TemplateActivator/Services/ValidatorService.cs

@@ -18,6 +18,7 @@ internal class ValidatorService : IValidatorService
         this.logger = logger;
     }
 
+
     public async Task<bool> IsValidApplicationInWorkAsync(Guid applicationInWorkId)
     {
         using (var scope = serviceProvider.CreateScope())

PARR.TemplateGeneratorWorker/ITemplateGenerator.cs

@@ -0,0 +1,7 @@
+namespace PARR.TemplateGeneratorWorker
+{
+    public interface ITemplateGenerator
+    {
+        Task GenerateTemplateAsync(string msg);
+    }
+}

PARR.TemplateGeneratorWorker/PARR.TemplateGeneratorWorker.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk.Worker">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UserSecretsId>dotnet-PARR.TemplateGeneratorWorker-4ea24dbb-6876-46db-9b6e-68e93850120e</UserSecretsId>
+    <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Elastic.CommonSchema.Serilog" Version="8.6.1" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.1" />
+    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.22.1-Preview.1" />
+    <PackageReference Include="Serilog.Extensions.Hosting" Version="7.0.0" />
+    <PackageReference Include="Serilog.Settings.Configuration" Version="7.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="4.1.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PARR.BLL\PARR.BLL.csproj" />
+    <ProjectReference Include="..\PARR.DAL\PARR.DAL.csproj" />
+  </ItemGroup>
+</Project>

PARR.TemplateGeneratorWorker/Program.cs

@@ -0,0 +1,30 @@
+using Elastic.CommonSchema.Serilog;
+using PARR.TemplateGeneratorWorker;
+using Serilog;
+
+var builder = Host.CreateApplicationBuilder();
+
+builder.Services.AddLogging(config =>
+{
+    config.ClearProviders();
+
+    var logger = new LoggerConfiguration();
+
+    if (builder.Environment.IsProduction())
+        logger.WriteTo.Console(new EcsTextFormatter());
+    else
+        logger.WriteTo.Console();
+
+    logger.ReadFrom.Configuration(builder.Configuration);
+
+    config.AddSerilog(logger.CreateLogger());
+});
+
+builder.Services.InstallTemplateGeneratorWorkerSerivces(builder.Configuration);
+builder.Configuration.AddTemplateGeneratorWorkerConfigurations(builder.Services);
+builder.Services.AddTemplateGeneratorWorkerSettings(builder.Configuration);
+
+builder.Services.AddHostedService<Worker>();
+
+var host = builder.Build();
+host.Run();

PARR.TemplateGeneratorWorker/Properties/launchSettings.json

@@ -0,0 +1,14 @@
+{
+  "profiles": {
+    "PARR.TemplateGeneratorWorker": {
+      "commandName": "Project",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      },
+      "dotnetRunMessages": true
+    },
+    "Container (Dockerfile)": {
+      "commandName": "Docker"
+    }
+  }
+}

PARR.TemplateGeneratorWorker/Services/IValidatorService.cs

@@ -0,0 +1,7 @@
+namespace PARR.TemplateGeneratorWorker.Services
+{
+    public interface IValidatorService
+    {
+        Task<bool> IsValidAsync(Guid jobId, Guid unitId);
+    }
+}

PARR.TemplateGeneratorWorker/Services/ValidatorService.cs

@@ -0,0 +1,51 @@
+using Microsoft.EntityFrameworkCore;
+using PARR.DAL.Services.Interfaces.Job;
+using PARR.DAL.Services.Interfaces.Unit;
+
+namespace PARR.TemplateGeneratorWorker.Services
+{
+    internal class ValidatorService : IValidatorService
+    {
+        private readonly ILogger<ValidatorService> logger;
+        private readonly IJobService jobService;
+        private readonly IUnitService unitService;
+
+        public ValidatorService(
+            ILogger<ValidatorService> logger,
+            IJobService jobService,
+            IUnitService unitService
+            )
+        {
+            this.logger = logger;
+            this.jobService = jobService;
+            this.unitService = unitService;
+        }
+
+
+        public async Task<bool> IsValidAsync(Guid jobId, Guid unitId)
+        {
+
+            var job = await jobService
+                                .Get().AsNoTracking()
+                                .FirstOrDefaultAsync(t => t.Id == jobId);
+
+            if (job == null)
+            {
+                logger.LogError($"Не найдена регалментная работа {nameof(jobId)}: {jobId}");
+                return false;
+            }
+
+            var unit = await unitService
+                .Get().AsNoTracking()
+                .FirstOrDefaultAsync(t => t.Id == unitId);
+
+            if (unit == null)
+            {
+                logger.LogError($"Не найден элемент конфигурации {nameof(unitId)}: {unitId}");
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

PARR.TemplateGeneratorWorker/Settings/MqSettings.cs

@@ -0,0 +1,12 @@
+using PARR.BLL.Contracts.Interfaces;
+
+namespace PARR.TemplateGeneratorWorker.Settings
+{
+    public class MqSettings : IMqSettings//TODO почему-то только публик работает
+    {
+        public string HostName { get; set; } = string.Empty;
+        public string QueueName { get; set; } = string.Empty;
+        public string User { get; set; } = string.Empty;
+        public string Password { get; set; } = string.Empty;
+    }
+}

PARR.TemplateGeneratorWorker/TemplateGenerator.cs

@@ -0,0 +1,86 @@
+
+using Microsoft.EntityFrameworkCore;
+using PARR.BLL.Domain.Mq;
+using PARR.BLL.Services.Interfaces;
+using PARR.Common.Domain;
+using PARR.Constants;
+using PARR.DAL.DomainServices.Interfaces;
+using PARR.DAL.Models;
+using PARR.DAL.Models.Job;
+using PARR.DAL.Models.Unit;
+using PARR.DAL.Services.Interfaces;
+using PARR.DAL.Services.Interfaces.Job;
+using PARR.TemplateGeneratorWorker.Services;
+
+namespace PARR.TemplateGeneratorWorker
+{
+    internal class TemplateGenerator : ITemplateGenerator
+    {
+        private readonly ILogger<TemplateGenerator> logger;
+        private readonly ITransformService transformService;
+        private readonly IValidatorService validatorService;
+        private readonly IJobService jobService;
+        private readonly IShortcodesService shortcodesService;
+        private readonly ITemplateService templateService;
+
+        public TemplateGenerator(
+            ILogger<TemplateGenerator> logger,
+            ITransformService transformService,
+            IValidatorService validatorService,
+            IJobService jobService,
+            IShortcodesService shortcodesService,
+            ITemplateService templateService
+            )
+        {
+            this.logger = logger;
+            this.transformService = transformService;
+            this.validatorService = validatorService;
+            this.jobService = jobService;
+            this.shortcodesService = shortcodesService;
+            this.templateService = templateService;
+        }
+        public async Task GenerateTemplateAsync(string msg)
+        {
+            logger.LogInformation($"Получили запрос: {msg}");
+
+            var query = transformService.GetModelFromJson<TemplateGeneratorWorkerMq>(msg);
+
+            if (query == null)
+                return;
+
+            if (!await validatorService.IsValidAsync(query.JobId, query.UnitId))
+            {
+                logger.LogError($"Некорректные параметры регламентной работы или Unit {nameof(Job)}: {query.JobId}, {nameof(Unit)}: {query.UnitId}");
+                return;
+            }
+
+            var job = await jobService
+                            .Get().AsNoTracking()
+                            .FirstOrDefaultAsync(t => t.Id == query.JobId);
+
+            var templateName = await shortcodesService.ApplyShortcodesAsync(job!.TemplateNameMask!, query.UnitId, query.JobId);
+
+            var template = new Template
+            {
+                Id = Guid.NewGuid(),
+                Name = templateName,
+                UnitId = query.UnitId,
+                JobId = query.JobId,
+                IsActiveTemplate = query.IsActiveTemplate ?? false,
+                IsActiveSchedule = query.IsActiveSchedule ?? false,
+                InitiatorComment = query.HistoryInitiator?.InitiatorComment,
+                InitiatorParrComponentId = query.HistoryInitiator?.InitiatorParrComponentId
+            };
+
+            if (!await templateService.CreateAsync(template) || !await templateService.CommitAsync(new HistoryInitiator { InitiatorComment = "Запрос на генерацию с тестового шаблона", InitiatorParrComponentId = ParrComponentsEnum.TemplateGenerator }))
+            {
+                logger.LogError($"Ошибка при создании шаблона: Name: {template.Name}, {nameof(template.Job)}: {template.Job}, {nameof(template.Unit)}: {template.UnitId}");
+            }
+            else
+            {
+                logger.LogInformation($"Создан шаблон: Name: {template.Name}, {nameof(template.Job)}: {template.JobId}, {nameof(template.Unit)}: {template.UnitId}");
+            }
+        }
+
+    }
+}

PARR.TemplateGeneratorWorker/TemplateGeneratorWorkerInstaller.cs

@@ -0,0 +1,35 @@
+using PARR.BLL;
+using PARR.DAL;
+using PARR.TemplateGeneratorWorker.Services;
+using PARR.TemplateGeneratorWorker.Settings;
+
+namespace PARR.TemplateGeneratorWorker
+{
+    public static class TemplateGeneratorWorkerInstaller
+    {
+        public static void InstallTemplateGeneratorWorkerSerivces(this IServiceCollection services, IConfiguration configuration)
+        {
+            services.InstallBllServices(configuration);
+            services.InstallDalServices(configuration);
+
+            var mqSettings = new MqSettings();
+            configuration.GetSection(nameof(MqSettings)).Bind(mqSettings);
+            services.AddSingleton(mqSettings);
+
+            services.AddTransient<ITemplateGenerator, TemplateGenerator>();
+            services.AddTransient<IValidatorService, ValidatorService>();
+        }
+
+        public static IConfigurationBuilder AddTemplateGeneratorWorkerConfigurations(this IConfigurationBuilder builder, IServiceCollection services)
+        {
+            builder.AddDalConfigurations(services);
+
+            return builder;
+        }
+
+        public static void AddTemplateGeneratorWorkerSettings(this IServiceCollection services, IConfiguration configuration)
+        {
+            services.AddDallSettings(configuration);
+        }
+    }
+}

PARR.TemplateGeneratorWorker/Worker.cs

@@ -0,0 +1,68 @@
+using PARR.BLL.Contracts.Interfaces;
+using PARR.BLL.Services.Interfaces;
+using PARR.DAL.DomainServices.Interfaces;
+using PARR.DAL.Services.Interfaces;
+using PARR.DAL.Services.Interfaces.Job;
+using PARR.TemplateGeneratorWorker.Services;
+using PARR.TemplateGeneratorWorker.Settings;
+
+namespace PARR.TemplateGeneratorWorker
+{
+    public class Worker : BackgroundService
+    {
+        private readonly ILogger<Worker> logger;
+        private readonly IMqSettings mqSettings;
+        private readonly IMqService mqService;
+        private readonly IServiceProvider serviceProvider;
+        private readonly ITransformService transformService;
+        private readonly IValidatorService validatorService;
+        private readonly IJobService jobService;
+        private readonly IShortcodesService shortcodesService;
+        private readonly ITemplateService templateService;
+
+        public Worker(
+            ILogger<Worker> logger,
+            MqSettings mqSettings,
+            IMqService mqService,
+            IServiceProvider serviceProvider
+            )
+        {
+            this.logger = logger;
+            this.mqSettings = mqSettings;
+            this.mqService = mqService;
+            this.serviceProvider = serviceProvider;
+        }
+
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                var isConnected = mqService.InitConsumer(mqSettings, GenerateTemplateAsync);
+
+                if (!isConnected)
+                    throw new Exception("<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> RabbitMq");
+            }
+        }
+
+
+        public override Task StopAsync(CancellationToken cancellationToken)
+        {
+            mqService.Dispose();
+
+            return base.StopAsync(cancellationToken);
+        }
+
+
+        private async Task GenerateTemplateAsync(string msg)
+        {
+            using (var scope = serviceProvider.CreateScope())
+            {
+                var templateGenerator = scope.ServiceProvider.GetService<ITemplateGenerator>();
+                if (templateGenerator == null)
+                    throw new Exception($"<22><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: {nameof(ITemplateGenerator)}");
+                await templateGenerator.GenerateTemplateAsync(msg);
+            }
+        }
+    }
+}
+

PARR.TemplateGeneratorWorker/appsettings.Development.json

@@ -0,0 +1,11 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "MqSettings": {
+    "HostName": "10.99.253.216"
+  }
+}

PARR.TemplateGeneratorWorker/appsettings.json

@@ -0,0 +1,35 @@
+{
+  "ConnectionStrings": {
+    "DefaultConnection": "Server=10.99.253.184;Database=parr;User Id=app_parr; Password=PosdfkhT&)%sdfligL&%5546;"
+  },
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "Serilog": {
+    "MinimumLevel": {
+      "Default": "Debug",
+      "Override": {
+        "Microsoft": "Warning",
+        "Microsoft.Hosting.Lifetime": "Debug"
+      }
+    },
+    "WriteTo": [
+      {
+        "Name": "File",
+        "Args": {
+          "path": "log/log-.txt",
+          "rollingInterval": "Day"
+        }
+      }
+    ]
+  },
+  "MqSettings": {
+    "HostName": "parr-rabbitmq",
+    "QueueName": "parr-template-generator",
+    "User": "template_generator_reader",
+    "Password": "Jy7vsoygcl7e0:Qy"
+  }
+}

PARR.Test/Worker.cs

@@ -35,28 +35,28 @@ namespace PARR.Test
         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         {
             #region test
-            //using (var scope = serviceProvider.CreateScope())
+            using (var scope = serviceProvider.CreateScope())
-            //{
+            {
-            //    var unitFilterService = scope.ServiceProvider.GetService<IUnitFilterService>();
+                var unitFilterService = scope.ServiceProvider.GetService<IUnitFilterService>();
 
-            //    if (unitFilterService == null)
+                if (unitFilterService == null)
-            //        return;
+                    return;
 
-            //    var jobId = Guid.Parse("58b28517-8178-4683-a519-22f5989c9912");
+                var jobId = Guid.Parse("926793f7-c6d3-4f08-b5ce-517ce1a1ac37");
-            //    var unitsId = await unitFilterService.GetUnitsIdByJobFilterAsync(jobId);
+                //var unitsId = await unitFilterService.GetUnitsIdByJobFilterAsync(jobId);
 
-            //    var unitService = scope.ServiceProvider.GetService<IUnitService>();
+                var unitService = scope.ServiceProvider.GetService<IUnitService>();
 
-            //    if (unitService == null)
+                if (unitService == null)
-            //        return;
+                    return;
 
-            //    var tForCreate = await unitFilterService.GetUnitsIdForExistTemplatesByJobFilterAsync(jobId);
+                var tForCreate = await unitFilterService.GetUnitsIdForExistTemplatesByJobFilterAsync(jobId);
-            //    if (tForCreate == null)
+                if (tForCreate == null)
-            //        return;
+                    return;
 
-            //    var units = await unitService
+                var units = await unitService
-            //                    .Get().AsNoTracking()
+                                .Get().AsNoTracking()
-            //                    .Where(t => tForCreate.Any(x => x == t.Id)).ToListAsync();
+                                .Where(t => tForCreate.Any(x => x == t.Id)).ToListAsync();
             }
             #endregion
 

docker-compose.dcproj

@@ -9,6 +9,7 @@
     <DockerServiceName>parr.api</DockerServiceName>
   </PropertyGroup>
   <ItemGroup>
+    <None Include="docker-compose.template-generator.yml" />
     <None Include="docker-compose.aihit-loader.yml" />
     <None Include="docker-compose.aihit-relationships-syncer.yml" />
     <None Include="docker-compose.aihit-syncer.yml" />

docker-compose.template-generator.yml

@@ -0,0 +1,25 @@
+version: '3.4'
+
+#PARR TEMPLATE ACTIVATOR
+services:
+  parr-template-activator:
+    image: harbor.dvgd.rzd/parr/parr-template-generator:${tag-latest}
+    environment:
+      - ASPNETCORE_ENVIRONMENT=Production
+      - TZ=Europe/Moscow
+    logging:
+      driver: fluentd
+      options:
+        fluentd-address: dvgd-efk-01.dvgd.oao.rzd:24224
+        fluentd-retry-wait: '30s'
+        fluentd-max-retries: '30'
+        tag: parr.template-generator.serilog
+    deploy:
+      replicas: 4  
+    networks:
+      parr-network:
+
+networks:
+  parr-network:
+    driver: overlay
+    external: true