main master

.gitea/workflows/test.yml

@@ -0,0 +1,40 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Install PostgreSQL
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y postgresql
+          sudo pg_ctlcluster 16 main start
+          sudo -u postgres psql -c "CREATE USER tnsu_approval_route WITH PASSWORD 'tnsu_approval_route' SUPERUSER;"
+          sudo -u postgres psql -c "CREATE DATABASE tnsu_approval_route OWNER tnsu_approval_route;"
+
+      - name: Restore
+        run: dotnet restore backend/Tnsu.ApprovalRoute.sln
+
+      - name: Build
+        run: dotnet build backend/Tnsu.ApprovalRoute.sln --no-restore -c Release
+
+      - name: Test
+        env:
+          TEST_POSTGRES_CONNECTION: "Host=localhost;Port=5432;Database=tnsu_approval_route;Username=tnsu_approval_route;Password=tnsu_approval_route"
+        run: dotnet test backend/Tnsu.ApprovalRoute.sln --no-build -c Release

backend/.idea/.idea.Tnsu.ApprovalRoute/.idea/indexLayout.xml

@@ -1,7 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="UserContentModel">
-    <attachedFolders />
+    <attachedFolders>
+      <Path>../.gitea/workflows</Path>
+    </attachedFolders>
     <explicitIncludes />
     <explicitExcludes />
   </component>

backend/Directory.Packages.props

@@ -5,12 +5,23 @@
   <ItemGroup>
     <PackageVersion Include="EFCore.NamingConventions" Version="10.0.1" />
     <PackageVersion Include="Extensions.Hosting.AsyncInitialization" Version="3.0.1" />
+    <PackageVersion Include="FluentResults" Version="4.0.0" />
+    <PackageVersion Include="FluentValidation" Version="12.1.1" />
+    <PackageVersion Include="FluentValidation.DependencyInjectionExtensions" Version="12.1.1" />
     <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.10" />
     <PackageVersion Include="Microsoft.AspNetCore.OpenApi" Version="10.0.10" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.10" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.10" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.10" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration" Version="10.0.10" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.10" />
+    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.10" />
     <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.3" />
-    <PackageVersion Include="MediatR" Version="14.2.0" />
+    <PackageVersion Include="Shouldly" Version="4.3.0" />
+    <PackageVersion Include="Swashbuckle.AspNetCore.SwaggerUI" Version="10.2.3" />
+    <PackageVersion Include="coverlet.collector" Version="6.0.4" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.4" />
   </ItemGroup>
 </Project>

backend/Tnsu.ApprovalRoute.sln

@@ -13,6 +13,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tnsu.ApprovalRoute.Infrastr
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tnsu.ApprovalRoute.Api", "src\Tnsu.ApprovalRoute.Api\Tnsu.ApprovalRoute.Api.csproj", "{4697B342-BE47-435B-B854-75F9277AD769}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0AB3BF05-4346-4AA6-1389-037BE0695223}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tnsu.ApprovalRoute.IntegrationTests", "tests\Tnsu.ApprovalRoute.IntegrationTests\Tnsu.ApprovalRoute.IntegrationTests.csproj", "{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -71,6 +75,18 @@ Global
 		{4697B342-BE47-435B-B854-75F9277AD769}.Release|x64.Build.0 = Release|Any CPU
 		{4697B342-BE47-435B-B854-75F9277AD769}.Release|x86.ActiveCfg = Release|Any CPU
 		{4697B342-BE47-435B-B854-75F9277AD769}.Release|x86.Build.0 = Release|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Debug|x64.Build.0 = Debug|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Debug|x86.Build.0 = Debug|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Release|x64.ActiveCfg = Release|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Release|x64.Build.0 = Release|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Release|x86.ActiveCfg = Release|Any CPU
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -80,5 +96,6 @@ Global
 		{2EEA333B-16C7-460E-BD07-AB1F32D6A9A9} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
 		{46EF4247-8B98-4CC9-A981-186C8D24163C} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
 		{4697B342-BE47-435B-B854-75F9277AD769} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
+		{F5E2BA0E-7978-414C-98D4-D3C91C162FDE} = {0AB3BF05-4346-4AA6-1389-037BE0695223}
 	EndGlobalSection
 EndGlobal

backend/src/Tnsu.ApprovalRoute.Api/Auth/AuthSchemes.cs

@@ -0,0 +1,6 @@
+namespace Tnsu.ApprovalRoute.Api.Auth;
+
+public static class AuthSchemes
+{
+    public const string Dev = "Dev";
+}

backend/src/Tnsu.ApprovalRoute.Api/Auth/AuthSetup.cs

@@ -0,0 +1,41 @@
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.IdentityModel.Tokens;
+
+namespace Tnsu.ApprovalRoute.Api.Auth;
+
+public static class AuthSetup
+{
+    public static IServiceCollection AddApprovalRouteAuth(this IServiceCollection services, IConfiguration configuration)
+    {
+        var tenantId = configuration["Entra:TenantId"];
+        var audience = configuration["Entra:Audience"];
+
+        if (!string.IsNullOrWhiteSpace(tenantId) && !string.IsNullOrWhiteSpace(audience))
+        {
+            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+                .AddJwtBearer(options =>
+                {
+                    options.Authority = $"https://login.microsoftonline.com/{tenantId}/v2.0";
+                    options.TokenValidationParameters = new TokenValidationParameters
+                    {
+                        ValidIssuers =
+                        [
+                            $"https://login.microsoftonline.com/{tenantId}/v2.0",
+                            $"https://sts.windows.net/{tenantId}/"
+                        ],
+                        ValidAudiences = [audience, $"api://{audience}"]
+                    };
+                });
+        }
+        else
+        {
+            services.AddAuthentication(AuthSchemes.Dev)
+                .AddScheme<AuthenticationSchemeOptions, DevAuthHandler>(AuthSchemes.Dev, _ => { });
+        }
+
+        services.AddAuthorization();
+
+        return services;
+    }
+}

backend/src/Tnsu.ApprovalRoute.Api/Auth/CurrentUserAccessor.cs

@@ -0,0 +1,11 @@
+using System.Security.Claims;
+using Tnsu.ApprovalRoute.Application.Common.Interfaces;
+
+namespace Tnsu.ApprovalRoute.Api.Auth;
+
+public sealed class CurrentUserAccessor(IHttpContextAccessor httpContextAccessor) : ICurrentUser
+{
+    public string? Email =>
+        httpContextAccessor.HttpContext?.User.FindFirstValue(ClaimTypes.Email)
+        ?? httpContextAccessor.HttpContext?.User.FindFirstValue("preferred_username");
+}

backend/src/Tnsu.ApprovalRoute.Api/Auth/DevAuthHandler.cs

@@ -0,0 +1,27 @@
+using System.Security.Claims;
+using System.Text.Encodings.Web;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.Extensions.Options;
+
+namespace Tnsu.ApprovalRoute.Api.Auth;
+
+// Используется только когда Entra:TenantId/Entra:Audience не заданы (локальная разработка без реального Entra ID).
+public sealed class DevAuthHandler(
+    IOptionsMonitor<AuthenticationSchemeOptions> options,
+    ILoggerFactory logger,
+    UrlEncoder encoder,
+    IConfiguration configuration)
+    : AuthenticationHandler<AuthenticationSchemeOptions>(options, logger, encoder)
+{
+    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
+    {
+        var email = Request.Headers["X-Dev-User-Email"].FirstOrDefault()
+            ?? configuration["Dev:DefaultUserEmail"]
+            ?? "dev@tnsu.kz";
+
+        var identity = new ClaimsIdentity([new Claim(ClaimTypes.Email, email)], AuthSchemes.Dev);
+        var ticket = new AuthenticationTicket(new ClaimsPrincipal(identity), AuthSchemes.Dev);
+
+        return Task.FromResult(AuthenticateResult.Success(ticket));
+    }
+}

backend/src/Tnsu.ApprovalRoute.Api/Common/ResultExtensions.cs

@@ -0,0 +1,33 @@
+using FluentResults;
+using Microsoft.AspNetCore.Mvc;
+using Tnsu.ApprovalRoute.Application.Common.Errors;
+
+namespace Tnsu.ApprovalRoute.Api.Common;
+
+public static class ResultExtensions
+{
+    public static IActionResult ToActionResult<T>(this Result<T> result)
+    {
+        if (result.IsFailed)
+            return result.Errors[0].ToActionResult();
+
+        var warnings = result.Reasons.OfType<Warning>().Select(w => w.Message).ToList();
+        return new OkObjectResult(new { data = result.Value, warnings });
+    }
+
+    public static IActionResult ToActionResult(this Result result)
+    {
+        if (result.IsFailed)
+            return result.Errors[0].ToActionResult();
+
+        return new NoContentResult();
+    }
+
+    private static IActionResult ToActionResult(this IError error) => error switch
+    {
+        NotFoundError => new NotFoundObjectResult(new { message = error.Message }),
+        ValidationError => new BadRequestObjectResult(new { message = error.Message }),
+        ConflictError => new ConflictObjectResult(new { message = error.Message }),
+        _ => new ObjectResult(new { message = error.Message }) { StatusCode = StatusCodes.Status500InternalServerError }
+    };
+}

backend/src/Tnsu.ApprovalRoute.Api/Controllers/RequestTypesController.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Tnsu.ApprovalRoute.Api.Common;
+using Tnsu.ApprovalRoute.Application.RequestTypes;
+
+namespace Tnsu.ApprovalRoute.Api.Controllers;
+
+[ApiController]
+[Authorize]
+[Route("api/request-types")]
+public sealed class RequestTypesController(RequestTypeService service) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> List(CancellationToken ct) =>
+        (await service.ListAsync(ct)).ToActionResult();
+
+    [HttpGet("{id:guid}")]
+    public async Task<IActionResult> Get(Guid id, CancellationToken ct) =>
+        (await service.GetAsync(id, ct)).ToActionResult();
+
+    [HttpPost]
+    public async Task<IActionResult> Create(CreateRequestTypeRequest body, CancellationToken ct) =>
+        (await service.CreateAsync(body, ct)).ToActionResult();
+
+    [HttpPut("{id:guid}")]
+    public async Task<IActionResult> Update(Guid id, UpdateRequestTypeRequest body, CancellationToken ct) =>
+        (await service.UpdateAsync(id, body, ct)).ToActionResult();
+
+    [HttpDelete("{id:guid}")]
+    public async Task<IActionResult> Delete(Guid id, CancellationToken ct) =>
+        (await service.DeleteAsync(id, ct)).ToActionResult();
+}

backend/src/Tnsu.ApprovalRoute.Api/Controllers/TemplateRouteStepsController.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Tnsu.ApprovalRoute.Api.Common;
+using Tnsu.ApprovalRoute.Application.TemplateRouteSteps;
+
+namespace Tnsu.ApprovalRoute.Api.Controllers;
+
+[ApiController]
+[Authorize]
+[Route("api/template-routes/{routeId:guid}/steps")]
+public sealed class TemplateRouteStepsController(TemplateRouteStepService service) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> List(Guid routeId, CancellationToken ct) =>
+        (await service.ListAsync(routeId, ct)).ToActionResult();
+
+    [HttpGet("{id:guid}")]
+    public async Task<IActionResult> Get(Guid routeId, Guid id, CancellationToken ct) =>
+        (await service.GetAsync(routeId, id, ct)).ToActionResult();
+
+    [HttpPost]
+    public async Task<IActionResult> Create(Guid routeId, CreateTemplateRouteStepRequest body, CancellationToken ct) =>
+        (await service.CreateAsync(routeId, body, ct)).ToActionResult();
+
+    [HttpPut("{id:guid}")]
+    public async Task<IActionResult> Update(Guid routeId, Guid id, UpdateTemplateRouteStepRequest body, CancellationToken ct) =>
+        (await service.UpdateAsync(routeId, id, body, ct)).ToActionResult();
+
+    [HttpDelete("{id:guid}")]
+    public async Task<IActionResult> Delete(Guid routeId, Guid id, CancellationToken ct) =>
+        (await service.DeleteAsync(routeId, id, ct)).ToActionResult();
+}

backend/src/Tnsu.ApprovalRoute.Api/Controllers/TemplateRoutesController.cs

@@ -0,0 +1,36 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Tnsu.ApprovalRoute.Api.Common;
+using Tnsu.ApprovalRoute.Application.TemplateRoutes;
+
+namespace Tnsu.ApprovalRoute.Api.Controllers;
+
+[ApiController]
+[Authorize]
+[Route("api/template-routes")]
+public sealed class TemplateRoutesController(TemplateRouteService service) : ControllerBase
+{
+    [HttpGet("resolve")]
+    public async Task<IActionResult> Resolve([FromQuery] ResolveTemplateRouteRequest request, CancellationToken ct) =>
+        (await service.ResolveAsync(request, ct)).ToActionResult();
+
+    [HttpGet]
+    public async Task<IActionResult> List([FromQuery] Guid? requestTypeId, CancellationToken ct) =>
+        (await service.ListAsync(requestTypeId, ct)).ToActionResult();
+
+    [HttpGet("{id:guid}")]
+    public async Task<IActionResult> Get(Guid id, CancellationToken ct) =>
+        (await service.GetAsync(id, ct)).ToActionResult();
+
+    [HttpPost]
+    public async Task<IActionResult> Create(CreateTemplateRouteRequest body, CancellationToken ct) =>
+        (await service.CreateAsync(body, ct)).ToActionResult();
+
+    [HttpPut("{id:guid}")]
+    public async Task<IActionResult> Update(Guid id, UpdateTemplateRouteRequest body, CancellationToken ct) =>
+        (await service.UpdateAsync(id, body, ct)).ToActionResult();
+
+    [HttpDelete("{id:guid}")]
+    public async Task<IActionResult> Delete(Guid id, CancellationToken ct) =>
+        (await service.DeleteAsync(id, ct)).ToActionResult();
+}

backend/src/Tnsu.ApprovalRoute.Api/Filters/ValidationActionFilter.cs

@@ -0,0 +1,35 @@
+using FluentValidation;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Tnsu.ApprovalRoute.Api.Filters;
+
+// Валидирует аргументы action'ов, для которых зарегистрирован IValidator<T> — без валидации внутри сервисов.
+public sealed class ValidationActionFilter(IServiceProvider serviceProvider) : IAsyncActionFilter
+{
+    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+    {
+        foreach (var argument in context.ActionArguments.Values)
+        {
+            if (argument is null)
+                continue;
+
+            var validatorType = typeof(IValidator<>).MakeGenericType(argument.GetType());
+            if (serviceProvider.GetService(validatorType) is not IValidator validator)
+                continue;
+
+            var validationContext = new ValidationContext<object>(argument);
+            var result = await validator.ValidateAsync(validationContext, context.HttpContext.RequestAborted);
+            if (result.IsValid)
+                continue;
+
+            context.Result = new BadRequestObjectResult(new
+            {
+                message = string.Join(" ", result.Errors.Select(e => e.ErrorMessage))
+            });
+            return;
+        }
+
+        await next();
+    }
+}

backend/src/Tnsu.ApprovalRoute.Api/Program.cs

@@ -1,24 +1,74 @@
+using System.Text.Json.Serialization;
 using Extensions.Hosting.AsyncInitialization;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.OpenApi;
+using Tnsu.ApprovalRoute.Api.Auth;
+using Tnsu.ApprovalRoute.Api.Filters;
 using Tnsu.ApprovalRoute.Application;
+using Tnsu.ApprovalRoute.Application.Common.Interfaces;
 using Tnsu.ApprovalRoute.Infrastructure;
 
 var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.AddApprovalRouteInfrastructure(builder.Configuration);
 builder.Services.AddApprovalRouteApplication();
-builder.Services.AddOpenApi();
+builder.Services.AddApprovalRouteAuth(builder.Configuration);
+builder.Services.AddHttpContextAccessor();
+builder.Services.AddScoped<ICurrentUser, CurrentUserAccessor>();
+builder.Services.AddOpenApi(options =>
+{
+    options.AddDocumentTransformer((document, _, _) =>
+    {
+        document.Components ??= new OpenApiComponents();
+        document.Components.SecuritySchemes ??= new Dictionary<string, IOpenApiSecurityScheme>();
+        document.Components.SecuritySchemes["Bearer"] = new OpenApiSecurityScheme
+        {
+            Type = SecuritySchemeType.Http,
+            Scheme = "bearer",
+            BearerFormat = "JWT",
+            Description = "Введите JWT токен"
+        };
+        return Task.CompletedTask;
+    });
+    options.AddOperationTransformer((operation, context, _) =>
+    {
+        operation.Security =
+        [
+            new OpenApiSecurityRequirement
+            {
+                [new OpenApiSecuritySchemeReference("Bearer", context.Document)] = []
+            }
+        ];
+        return Task.CompletedTask;
+    });
+});
 builder.Services.AddHealthChecks();
+builder.Services.AddControllers(options => options.Filters.Add<ValidationActionFilter>())
+    .AddJsonOptions(o => o.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));
 
 var app = builder.Build();
 
 if (app.Environment.IsDevelopment())
+{
     app.MapOpenApi();
+    app.UseSwaggerUI(c =>
+    {
+        c.SwaggerEndpoint("/openapi/v1.json", "Tnsu Approval Route v1");
+        c.RoutePrefix = string.Empty;
+        c.ConfigObject.AdditionalItems["persistAuthorization"] = true;
+        c.EnableTryItOutByDefault();
+    });
+}
 
 app.MapHealthChecks("/health");
 
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapControllers();
+
 await app.InitAndRunAsync();
 
 public partial class Program;

backend/src/Tnsu.ApprovalRoute.Api/Properties/launchSettings.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": false,
+      "applicationUrl": "http://localhost:5080",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

backend/src/Tnsu.ApprovalRoute.Api/Tnsu.ApprovalRoute.Api.csproj

@@ -7,10 +7,10 @@
     <PackageReference Include="Extensions.Hosting.AsyncInitialization" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" />
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" />
-    <PackageReference Include="MediatR" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" />
   </ItemGroup>
 </Project>

backend/src/Tnsu.ApprovalRoute.Api/appsettings.json

@@ -7,5 +7,19 @@
   },
   "ConnectionStrings": {
     "Postgres": "Host=localhost;Port=5435;Database=tnsu_approval_route;Username=tnsu_approval_route;Password=tnsu_approval_route"
+  },
+  "Entra": {
+    "TenantId": "",
+    "Audience": ""
+  },
+  "Dev": {
+    "DefaultUserEmail": "dev@tnsu.kz"
+  },
+  "TnsuPortal": {
+    "BaseUrl": "https://api.tnsu.kz",
+    "TenantId": "",
+    "ClientId": "",
+    "ClientSecret": "",
+    "Scope": ""
   }
 }

backend/src/Tnsu.ApprovalRoute.Application/ApplicationServiceCollectionExtensions.cs

@@ -1,6 +1,9 @@
 using System.Reflection;
-using MediatR;
+using FluentValidation;
 using Microsoft.Extensions.DependencyInjection;
+using Tnsu.ApprovalRoute.Application.RequestTypes;
+using Tnsu.ApprovalRoute.Application.TemplateRoutes;
+using Tnsu.ApprovalRoute.Application.TemplateRouteSteps;
 
 namespace Tnsu.ApprovalRoute.Application;
 
@@ -8,7 +11,12 @@ public static class ApplicationServiceCollectionExtensions
 {
     public static IServiceCollection AddApprovalRouteApplication(this IServiceCollection services)
     {
-        services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));
+        services.AddScoped<RequestTypeService>();
+        services.AddScoped<TemplateRouteService>();
+        services.AddScoped<TemplateRouteStepService>();
+
+        services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
+
         return services;
     }
 }

backend/src/Tnsu.ApprovalRoute.Application/Common/Errors/ApiErrors.cs

@@ -0,0 +1,12 @@
+using FluentResults;
+
+namespace Tnsu.ApprovalRoute.Application.Common.Errors;
+
+public sealed class NotFoundError(string entity, Guid id)
+    : Error($"{entity} с id {id} не найден.");
+
+public sealed class ValidationError(string message) : Error(message);
+
+public sealed class ConflictError(string message) : Error(message);
+
+public sealed class Warning(string message) : Success(message);

backend/src/Tnsu.ApprovalRoute.Application/Common/Interfaces/ICurrentUser.cs

@@ -0,0 +1,6 @@
+namespace Tnsu.ApprovalRoute.Application.Common.Interfaces;
+
+public interface ICurrentUser
+{
+    string? Email { get; }
+}

backend/src/Tnsu.ApprovalRoute.Application/RequestTypes/RequestTypeDto.cs

@@ -0,0 +1,7 @@
+namespace Tnsu.ApprovalRoute.Application.RequestTypes;
+
+public sealed record RequestTypeDto(Guid Id, string Name, string PageUrl);
+
+public sealed record CreateRequestTypeRequest(string Name, string PageUrl);
+
+public sealed record UpdateRequestTypeRequest(string Name, string PageUrl);

backend/src/Tnsu.ApprovalRoute.Application/RequestTypes/RequestTypeService.cs

@@ -0,0 +1,65 @@
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using Tnsu.ApprovalRoute.Application.Common.Errors;
+using Tnsu.ApprovalRoute.Domain.Entities;
+using Tnsu.ApprovalRoute.Infrastructure.Persistence;
+
+namespace Tnsu.ApprovalRoute.Application.RequestTypes;
+
+public sealed class RequestTypeService(ApprovalRouteDbContext db)
+{
+    public async Task<Result<IReadOnlyList<RequestTypeDto>>> ListAsync(CancellationToken cancellationToken)
+    {
+        var items = await db.RequestTypes.AsNoTracking()
+            .OrderBy(x => x.Name)
+            .Select(x => new RequestTypeDto(x.Id, x.Name, x.PageUrl))
+            .ToListAsync(cancellationToken);
+
+        return Result.Ok<IReadOnlyList<RequestTypeDto>>(items);
+    }
+
+    public async Task<Result<RequestTypeDto>> GetAsync(Guid id, CancellationToken cancellationToken)
+    {
+        var entity = await db.RequestTypes.AsNoTracking().FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+
+        return entity is null
+            ? Result.Fail<RequestTypeDto>(new NotFoundError("Тип заявки", id))
+            : Result.Ok(ToDto(entity));
+    }
+
+    public async Task<Result<RequestTypeDto>> CreateAsync(CreateRequestTypeRequest request, CancellationToken cancellationToken)
+    {
+        var entity = new RequestType { Name = request.Name, PageUrl = request.PageUrl };
+        db.RequestTypes.Add(entity);
+        await db.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok(ToDto(entity));
+    }
+
+    public async Task<Result<RequestTypeDto>> UpdateAsync(Guid id, UpdateRequestTypeRequest request, CancellationToken cancellationToken)
+    {
+        var entity = await db.RequestTypes.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+        if (entity is null)
+            return Result.Fail<RequestTypeDto>(new NotFoundError("Тип заявки", id));
+
+        entity.Name = request.Name;
+        entity.PageUrl = request.PageUrl;
+        await db.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok(ToDto(entity));
+    }
+
+    public async Task<Result> DeleteAsync(Guid id, CancellationToken cancellationToken)
+    {
+        var entity = await db.RequestTypes.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+        if (entity is null)
+            return Result.Fail(new NotFoundError("Тип заявки", id));
+
+        db.RequestTypes.Remove(entity);
+        await db.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok();
+    }
+
+    private static RequestTypeDto ToDto(RequestType e) => new(e.Id, e.Name, e.PageUrl);
+}

backend/src/Tnsu.ApprovalRoute.Application/RequestTypes/RequestTypeValidators.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+
+namespace Tnsu.ApprovalRoute.Application.RequestTypes;
+
+public sealed class CreateRequestTypeRequestValidator : AbstractValidator<CreateRequestTypeRequest>
+{
+    public CreateRequestTypeRequestValidator()
+    {
+        RuleFor(x => x.Name).NotEmpty().WithMessage("Имя типа заявки обязательно.");
+        RuleFor(x => x.PageUrl).NotEmpty().WithMessage("Url страницы обязателен.");
+    }
+}
+
+public sealed class UpdateRequestTypeRequestValidator : AbstractValidator<UpdateRequestTypeRequest>
+{
+    public UpdateRequestTypeRequestValidator()
+    {
+        RuleFor(x => x.Name).NotEmpty().WithMessage("Имя типа заявки обязательно.");
+        RuleFor(x => x.PageUrl).NotEmpty().WithMessage("Url страницы обязателен.");
+    }
+}

backend/src/Tnsu.ApprovalRoute.Application/TemplateRouteSteps/TemplateRouteStepDto.cs

@@ -0,0 +1,32 @@
+using Tnsu.ApprovalRoute.Domain.Enums;
+
+namespace Tnsu.ApprovalRoute.Application.TemplateRouteSteps;
+
+public sealed record TemplateRouteStepDto(
+    Guid Id,
+    int OrderNo,
+    string ExecutorEmail,
+    string Position,
+    ProjectRole ProjectRole,
+    HeadType HeadType,
+    RouteStepStatus Status,
+    Guid RouteId,
+    bool AllowReassignToOtherApprovers);
+
+public sealed record CreateTemplateRouteStepRequest(
+    int OrderNo,
+    string ExecutorEmail,
+    string Position,
+    ProjectRole ProjectRole,
+    HeadType HeadType,
+    RouteStepStatus Status,
+    bool AllowReassignToOtherApprovers);
+
+public sealed record UpdateTemplateRouteStepRequest(
+    int OrderNo,
+    string ExecutorEmail,
+    string Position,
+    ProjectRole ProjectRole,
+    HeadType HeadType,
+    RouteStepStatus Status,
+    bool AllowReassignToOtherApprovers);

backend/src/Tnsu.ApprovalRoute.Application/TemplateRouteSteps/TemplateRouteStepService.cs

@@ -0,0 +1,118 @@
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using Tnsu.ApprovalRoute.Application.Common.Errors;
+using Tnsu.ApprovalRoute.Domain.Entities;
+using Tnsu.ApprovalRoute.Domain.Enums;
+using Tnsu.ApprovalRoute.Infrastructure.Persistence;
+
+namespace Tnsu.ApprovalRoute.Application.TemplateRouteSteps;
+
+public sealed class TemplateRouteStepService(ApprovalRouteDbContext db)
+{
+    public async Task<Result<IReadOnlyList<TemplateRouteStepDto>>> ListAsync(Guid routeId, CancellationToken cancellationToken)
+    {
+        var items = await db.TemplateRouteSteps.AsNoTracking()
+            .Where(x => x.RouteId == routeId)
+            .OrderBy(x => x.OrderNo)
+            .Select(x => new TemplateRouteStepDto(
+                x.Id, x.OrderNo, x.ExecutorEmail, x.Position, x.ProjectRole, x.HeadType, x.Status, x.RouteId, x.AllowReassignToOtherApprovers))
+            .ToListAsync(cancellationToken);
+
+        return Result.Ok<IReadOnlyList<TemplateRouteStepDto>>(items);
+    }
+
+    public async Task<Result<TemplateRouteStepDto>> GetAsync(Guid routeId, Guid id, CancellationToken cancellationToken)
+    {
+        var entity = await db.TemplateRouteSteps.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == id && x.RouteId == routeId, cancellationToken);
+
+        return entity is null
+            ? Result.Fail<TemplateRouteStepDto>(new NotFoundError("Шаг маршрута", id))
+            : Result.Ok(ToDto(entity));
+    }
+
+    public async Task<Result<TemplateRouteStepDto>> CreateAsync(Guid routeId, CreateTemplateRouteStepRequest r, CancellationToken cancellationToken)
+    {
+        var route = await db.TemplateRoutes.FirstOrDefaultAsync(x => x.Id == routeId, cancellationToken);
+        if (route is null)
+            return Result.Fail<TemplateRouteStepDto>(new NotFoundError("Маршрут", routeId));
+
+        if (!route.ByProject && r.ProjectRole != ProjectRole.None)
+            return Result.Fail<TemplateRouteStepDto>(new ValidationError(
+                "Роль в проекте недопустима для шага маршрута, который не учитывает проект (by_project = false)."));
+
+        var entity = new TemplateRouteStep
+        {
+            RouteId = route.Id,
+            OrderNo = r.OrderNo,
+            ExecutorEmail = r.ExecutorEmail,
+            Position = r.Position,
+            ProjectRole = r.ProjectRole,
+            HeadType = r.HeadType,
+            Status = r.Status,
+            AllowReassignToOtherApprovers = r.AllowReassignToOtherApprovers
+        };
+        db.TemplateRouteSteps.Add(entity);
+        await db.SaveChangesAsync(cancellationToken);
+
+        var result = Result.Ok(ToDto(entity));
+        return await AppendMissingProjectRoleWarningAsync(route, result, cancellationToken);
+    }
+
+    public async Task<Result<TemplateRouteStepDto>> UpdateAsync(
+        Guid routeId, Guid id, UpdateTemplateRouteStepRequest r, CancellationToken cancellationToken)
+    {
+        var route = await db.TemplateRoutes.FirstOrDefaultAsync(x => x.Id == routeId, cancellationToken);
+        if (route is null)
+            return Result.Fail<TemplateRouteStepDto>(new NotFoundError("Маршрут", routeId));
+
+        var entity = await db.TemplateRouteSteps.FirstOrDefaultAsync(x => x.Id == id && x.RouteId == routeId, cancellationToken);
+        if (entity is null)
+            return Result.Fail<TemplateRouteStepDto>(new NotFoundError("Шаг маршрута", id));
+
+        if (!route.ByProject && r.ProjectRole != ProjectRole.None)
+            return Result.Fail<TemplateRouteStepDto>(new ValidationError(
+                "Роль в проекте недопустима для шага маршрута, который не учитывает проект (by_project = false)."));
+
+        entity.OrderNo = r.OrderNo;
+        entity.ExecutorEmail = r.ExecutorEmail;
+        entity.Position = r.Position;
+        entity.ProjectRole = r.ProjectRole;
+        entity.HeadType = r.HeadType;
+        entity.Status = r.Status;
+        entity.AllowReassignToOtherApprovers = r.AllowReassignToOtherApprovers;
+        await db.SaveChangesAsync(cancellationToken);
+
+        var result = Result.Ok(ToDto(entity));
+        return await AppendMissingProjectRoleWarningAsync(route, result, cancellationToken);
+    }
+
+    public async Task<Result> DeleteAsync(Guid routeId, Guid id, CancellationToken cancellationToken)
+    {
+        var entity = await db.TemplateRouteSteps.FirstOrDefaultAsync(x => x.Id == id && x.RouteId == routeId, cancellationToken);
+        if (entity is null)
+            return Result.Fail(new NotFoundError("Шаг маршрута", id));
+
+        db.TemplateRouteSteps.Remove(entity);
+        await db.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok();
+    }
+
+    private async Task<Result<TemplateRouteStepDto>> AppendMissingProjectRoleWarningAsync(
+        TemplateRoute route, Result<TemplateRouteStepDto> result, CancellationToken cancellationToken)
+    {
+        if (!route.ByProject)
+            return result;
+
+        var hasProjectRoleStep = await db.TemplateRouteSteps
+            .AnyAsync(x => x.RouteId == route.Id && x.ProjectRole != ProjectRole.None, cancellationToken);
+
+        return hasProjectRoleStep
+            ? result
+            : result.WithReason(new Warning("Должен быть хотя бы один шаг с ролью в проекте."));
+    }
+
+    private static TemplateRouteStepDto ToDto(TemplateRouteStep e) => new(
+        e.Id, e.OrderNo, e.ExecutorEmail, e.Position, e.ProjectRole, e.HeadType, e.Status, e.RouteId, e.AllowReassignToOtherApprovers);
+}

backend/src/Tnsu.ApprovalRoute.Application/TemplateRouteSteps/TemplateRouteStepValidators.cs

@@ -0,0 +1,24 @@
+using FluentValidation;
+using Tnsu.ApprovalRoute.Domain.Enums;
+
+namespace Tnsu.ApprovalRoute.Application.TemplateRouteSteps;
+
+public sealed class CreateTemplateRouteStepRequestValidator : AbstractValidator<CreateTemplateRouteStepRequest>
+{
+    public CreateTemplateRouteStepRequestValidator()
+    {
+        RuleFor(x => x)
+            .Must(x => !(string.IsNullOrWhiteSpace(x.ExecutorEmail) && string.IsNullOrWhiteSpace(x.Position) && x.ProjectRole == ProjectRole.None))
+            .WithMessage("Исполнитель, должность и роль в проекте не могут быть пустыми одновременно.");
+    }
+}
+
+public sealed class UpdateTemplateRouteStepRequestValidator : AbstractValidator<UpdateTemplateRouteStepRequest>
+{
+    public UpdateTemplateRouteStepRequestValidator()
+    {
+        RuleFor(x => x)
+            .Must(x => !(string.IsNullOrWhiteSpace(x.ExecutorEmail) && string.IsNullOrWhiteSpace(x.Position) && x.ProjectRole == ProjectRole.None))
+            .WithMessage("Исполнитель, должность и роль в проекте не могут быть пустыми одновременно.");
+    }
+}

backend/src/Tnsu.ApprovalRoute.Application/TemplateRoutes/ResolveTemplateRouteDto.cs

@@ -0,0 +1,25 @@
+using Tnsu.ApprovalRoute.Domain.Enums;
+
+namespace Tnsu.ApprovalRoute.Application.TemplateRoutes;
+
+public sealed record ResolvedRouteStepDto(
+    Guid Id,
+    int OrderNo,
+    string ExecutorEmail,
+    string Position,
+    ProjectRole ProjectRole,
+    HeadType HeadType,
+    RouteStepStatus Status,
+    bool AllowReassignToOtherApprovers);
+
+public sealed record ResolveTemplateRouteResultDto(
+    Guid RouteId,
+    RouteType RouteType,
+    bool RequiresControl,
+    IReadOnlyList<ResolvedRouteStepDto> Steps);
+
+public sealed record ResolveTemplateRouteRequest(
+    Guid RequestTypeId,
+    string? UserEmail,
+    Guid? ProjectId,
+    RouteStepStatus Status);

backend/src/Tnsu.ApprovalRoute.Application/TemplateRoutes/TemplateRouteDto.cs

@@ -0,0 +1,27 @@
+using Tnsu.ApprovalRoute.Domain.Enums;
+
+namespace Tnsu.ApprovalRoute.Application.TemplateRoutes;
+
+public sealed record TemplateRouteDto(
+    Guid Id,
+    RouteType RouteType,
+    Guid RequestTypeId,
+    Guid? DepartmentId,
+    Guid CompanyId,
+    bool ByProject,
+    bool RequiresControl);
+
+public sealed record CreateTemplateRouteRequest(
+    RouteType RouteType,
+    Guid RequestTypeId,
+    Guid? DepartmentId,
+    Guid CompanyId,
+    bool ByProject,
+    bool RequiresControl);
+
+public sealed record UpdateTemplateRouteRequest(
+    RouteType RouteType,
+    Guid? DepartmentId,
+    Guid CompanyId,
+    bool ByProject,
+    bool RequiresControl);

backend/src/Tnsu.ApprovalRoute.Application/TemplateRoutes/TemplateRouteService.cs

@@ -0,0 +1,179 @@
+using FluentResults;
+using Microsoft.EntityFrameworkCore;
+using Tnsu.ApprovalRoute.Application.Common.Errors;
+using Tnsu.ApprovalRoute.Application.Common.Interfaces;
+using Tnsu.ApprovalRoute.Domain.Entities;
+using Tnsu.ApprovalRoute.Domain.Enums;
+using Tnsu.ApprovalRoute.Infrastructure.Persistence;
+using Tnsu.ApprovalRoute.Infrastructure.TnsuPortal;
+
+namespace Tnsu.ApprovalRoute.Application.TemplateRoutes;
+
+public sealed class TemplateRouteService(
+    ApprovalRouteDbContext db,
+    HttpTnsuPortalClient portalClient,
+    ICurrentUser currentUser)
+{
+    public async Task<Result<IReadOnlyList<TemplateRouteDto>>> ListAsync(Guid? requestTypeId, CancellationToken cancellationToken)
+    {
+        var query = db.TemplateRoutes.AsNoTracking().AsQueryable();
+        if (requestTypeId is { } id)
+            query = query.Where(x => x.RequestTypeId == id);
+
+        var items = await query
+            .Select(x => new TemplateRouteDto(
+                x.Id, x.RouteType, x.RequestTypeId, x.DepartmentId, x.CompanyId, x.ByProject, x.RequiresControl))
+            .ToListAsync(cancellationToken);
+
+        return Result.Ok<IReadOnlyList<TemplateRouteDto>>(items);
+    }
+
+    public async Task<Result<TemplateRouteDto>> GetAsync(Guid id, CancellationToken cancellationToken)
+    {
+        var entity = await db.TemplateRoutes.AsNoTracking().FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+
+        return entity is null
+            ? Result.Fail<TemplateRouteDto>(new NotFoundError("Маршрут", id))
+            : Result.Ok(ToDto(entity));
+    }
+
+    public async Task<Result<TemplateRouteDto>> CreateAsync(CreateTemplateRouteRequest r, CancellationToken cancellationToken)
+    {
+        var requestTypeExists = await db.RequestTypes.AnyAsync(x => x.Id == r.RequestTypeId, cancellationToken);
+        if (!requestTypeExists)
+            return Result.Fail<TemplateRouteDto>(new NotFoundError("Тип заявки", r.RequestTypeId));
+
+        var duplicate = await HasDuplicateAsync(r.RequestTypeId, r.DepartmentId, r.CompanyId, r.ByProject, excludeId: null, cancellationToken);
+        if (duplicate)
+            return Result.Fail<TemplateRouteDto>(new ConflictError(
+                "Маршрут с таким типом заявки, отделом, компанией и признаком «по проекту» уже существует."));
+
+        var entity = new TemplateRoute
+        {
+            RouteType = r.RouteType,
+            RequestTypeId = r.RequestTypeId,
+            DepartmentId = r.DepartmentId,
+            CompanyId = r.CompanyId,
+            ByProject = r.ByProject,
+            RequiresControl = r.RequiresControl
+        };
+        db.TemplateRoutes.Add(entity);
+        await db.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok(ToDto(entity));
+    }
+
+    public async Task<Result<TemplateRouteDto>> UpdateAsync(Guid id, UpdateTemplateRouteRequest r, CancellationToken cancellationToken)
+    {
+        var entity = await db.TemplateRoutes.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+        if (entity is null)
+            return Result.Fail<TemplateRouteDto>(new NotFoundError("Маршрут", id));
+
+        var duplicate = await HasDuplicateAsync(entity.RequestTypeId, r.DepartmentId, r.CompanyId, r.ByProject, excludeId: entity.Id, cancellationToken);
+        if (duplicate)
+            return Result.Fail<TemplateRouteDto>(new ConflictError(
+                "Маршрут с таким типом заявки, отделом, компанией и признаком «по проекту» уже существует."));
+
+        entity.RouteType = r.RouteType;
+        entity.DepartmentId = r.DepartmentId;
+        entity.CompanyId = r.CompanyId;
+        entity.ByProject = r.ByProject;
+        entity.RequiresControl = r.RequiresControl;
+        await db.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok(ToDto(entity));
+    }
+
+    public async Task<Result> DeleteAsync(Guid id, CancellationToken cancellationToken)
+    {
+        var entity = await db.TemplateRoutes.FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+        if (entity is null)
+            return Result.Fail(new NotFoundError("Маршрут", id));
+
+        db.TemplateRoutes.Remove(entity);
+        await db.SaveChangesAsync(cancellationToken);
+
+        return Result.Ok();
+    }
+
+    public async Task<Result<ResolveTemplateRouteResultDto>> ResolveAsync(
+        ResolveTemplateRouteRequest request, CancellationToken cancellationToken)
+    {
+        var email = string.IsNullOrWhiteSpace(request.UserEmail) ? currentUser.Email : request.UserEmail;
+        if (string.IsNullOrWhiteSpace(email))
+            return Result.Fail<ResolveTemplateRouteResultDto>(
+                new ValidationError("Не удалось определить email инициатора: не передан явно и отсутствует в токене."));
+
+        var requestTypeExists = await db.RequestTypes.AnyAsync(x => x.Id == request.RequestTypeId, cancellationToken);
+        if (!requestTypeExists)
+            return Result.Fail<ResolveTemplateRouteResultDto>(new NotFoundError("Тип заявки", request.RequestTypeId));
+
+        var employee = await portalClient.GetEmployeeByEmailAsync(email, cancellationToken);
+        var byProject = request.ProjectId is not null;
+
+        var route = await db.TemplateRoutes.AsNoTracking()
+            .Include(x => x.Steps)
+            .Where(x =>
+                x.RequestTypeId == request.RequestTypeId &&
+                x.CompanyId == employee.CompanyId &&
+                x.ByProject == byProject &&
+                x.DepartmentId == employee.DepartmentId)
+            .FirstOrDefaultAsync(cancellationToken)
+            ?? await db.TemplateRoutes.AsNoTracking()
+                .Include(x => x.Steps)
+                .Where(x =>
+                    x.RequestTypeId == request.RequestTypeId &&
+                    x.CompanyId == employee.CompanyId &&
+                    x.ByProject == byProject &&
+                    x.DepartmentId == null)
+                .FirstOrDefaultAsync(cancellationToken);
+
+        if (route is null)
+            return Result.Fail<ResolveTemplateRouteResultDto>(new NotFoundError(
+                "Маршрут для этого типа заявки, отдела/компании инициатора и признака «по проекту»",
+                request.RequestTypeId));
+
+        IReadOnlyList<ProjectExecutorInfo> projectExecutors = [];
+        if (request.ProjectId is { } projectId)
+            projectExecutors = await portalClient.GetProjectExecutorsAsync(projectId, cancellationToken);
+
+        var steps = route.Steps
+            .Where(s => s.Status == request.Status)
+            .OrderBy(s => s.OrderNo)
+            .Select(s => ResolveStep(s, projectExecutors))
+            .ToList();
+
+        return Result.Ok(new ResolveTemplateRouteResultDto(route.Id, route.RouteType, route.RequiresControl, steps));
+    }
+
+    private Task<bool> HasDuplicateAsync(
+        Guid requestTypeId, Guid? departmentId, Guid companyId, bool byProject, Guid? excludeId, CancellationToken cancellationToken) =>
+        db.TemplateRoutes.AnyAsync(x =>
+            x.Id != excludeId &&
+            x.RequestTypeId == requestTypeId &&
+            x.DepartmentId == departmentId &&
+            x.CompanyId == companyId &&
+            x.ByProject == byProject,
+            cancellationToken);
+
+    private static ResolvedRouteStepDto ResolveStep(TemplateRouteStep step, IReadOnlyList<ProjectExecutorInfo> projectExecutors)
+    {
+        // Для шагов с ролью в проекте фактический исполнитель приходит из данных проекта (api.tnsu.kz),
+        // а не из статичного ExecutorEmail шаблона — тот используется только для шагов без привязки к проекту.
+        if (step.ProjectRole != ProjectRole.None)
+        {
+            var projectExecutor = projectExecutors.FirstOrDefault(e => e.ProjectRole == step.ProjectRole);
+            if (projectExecutor is not null)
+                return new ResolvedRouteStepDto(
+                    step.Id, step.OrderNo, projectExecutor.Email, projectExecutor.Position,
+                    step.ProjectRole, step.HeadType, step.Status, step.AllowReassignToOtherApprovers);
+        }
+
+        return new ResolvedRouteStepDto(
+            step.Id, step.OrderNo, step.ExecutorEmail, step.Position,
+            step.ProjectRole, step.HeadType, step.Status, step.AllowReassignToOtherApprovers);
+    }
+
+    private static TemplateRouteDto ToDto(TemplateRoute e) => new(
+        e.Id, e.RouteType, e.RequestTypeId, e.DepartmentId, e.CompanyId, e.ByProject, e.RequiresControl);
+}

backend/src/Tnsu.ApprovalRoute.Application/TemplateRoutes/TemplateRouteValidators.cs

@@ -0,0 +1,28 @@
+using FluentValidation;
+using Tnsu.ApprovalRoute.Domain.Enums;
+
+namespace Tnsu.ApprovalRoute.Application.TemplateRoutes;
+
+public sealed class CreateTemplateRouteRequestValidator : AbstractValidator<CreateTemplateRouteRequest>
+{
+    public CreateTemplateRouteRequestValidator()
+    {
+        RuleFor(x => x.CompanyId).NotEqual(Guid.Empty).WithMessage("Компания обязательна.");
+    }
+}
+
+public sealed class UpdateTemplateRouteRequestValidator : AbstractValidator<UpdateTemplateRouteRequest>
+{
+    public UpdateTemplateRouteRequestValidator()
+    {
+        RuleFor(x => x.CompanyId).NotEqual(Guid.Empty).WithMessage("Компания обязательна.");
+    }
+}
+
+public sealed class ResolveTemplateRouteRequestValidator : AbstractValidator<ResolveTemplateRouteRequest>
+{
+    public ResolveTemplateRouteRequestValidator()
+    {
+        RuleFor(x => x.Status).NotEqual(RouteStepStatus.None).WithMessage("Статус обязателен: Approval или Execution.");
+    }
+}

backend/src/Tnsu.ApprovalRoute.Application/Tnsu.ApprovalRoute.Application.csproj

@@ -1,8 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <ItemGroup>
     <ProjectReference Include="..\Tnsu.ApprovalRoute.Domain\Tnsu.ApprovalRoute.Domain.csproj" />
+    <ProjectReference Include="..\Tnsu.ApprovalRoute.Infrastructure\Tnsu.ApprovalRoute.Infrastructure.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="MediatR" />
+    <PackageReference Include="FluentResults" />
+    <PackageReference Include="FluentValidation" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" />
   </ItemGroup>
 </Project>

backend/src/Tnsu.ApprovalRoute.Domain/Entities/RequestType.cs

@@ -9,5 +9,5 @@ public class RequestType
     public string Name { get; set; } = string.Empty;
     public string PageUrl { get; set; } = string.Empty;
 
-    public ICollection<Route> Routes { get; set; } = new List<Route>();
+    public ICollection<TemplateRoute> Routes { get; set; } = new List<TemplateRoute>();
 }

backend/src/Tnsu.ApprovalRoute.Domain/Entities/TemplateRoute.cs

@@ -2,19 +2,19 @@ using Tnsu.ApprovalRoute.Domain.Enums;
 
 namespace Tnsu.ApprovalRoute.Domain.Entities;
 
-public class Route
+public class TemplateRoute
 {
     public Guid Id { get; set; } = Guid.NewGuid();
     public RouteType RouteType { get; set; } = RouteType.Sequential;
     public Guid RequestTypeId { get; set; }
 
     // Внешние справочники (1С/ZUP) — хранятся как ссылки без FK в этой БД.
-    public Guid DepartmentId { get; set; }
+    public Guid? DepartmentId { get; set; }
     public Guid CompanyId { get; set; }
     public bool ByProject { get; set; }
 
     public bool RequiresControl { get; set; }
 
     public RequestType? RequestType { get; set; }
-    public ICollection<RouteStep> Steps { get; set; } = new List<RouteStep>();
+    public ICollection<TemplateRouteStep> Steps { get; set; } = new List<TemplateRouteStep>();
 }

backend/src/Tnsu.ApprovalRoute.Domain/Entities/TemplateRouteStep.cs

@@ -2,7 +2,7 @@ using Tnsu.ApprovalRoute.Domain.Enums;
 
 namespace Tnsu.ApprovalRoute.Domain.Entities;
 
-public class RouteStep
+public class TemplateRouteStep
 {
     public Guid Id { get; set; } = Guid.NewGuid();
     public int OrderNo { get; set; }
@@ -11,10 +11,11 @@ public class RouteStep
     public string ExecutorEmail { get; set; } = string.Empty;
     public string Position { get; set; } = string.Empty;
     public ProjectRole ProjectRole { get; set; } = ProjectRole.None;
+    public HeadType HeadType { get; set; } = HeadType.None;
 
-    public RouteStepStatus Status { get; set; } = RouteStepStatus.Draft;
+    public RouteStepStatus Status { get; set; } = RouteStepStatus.Approval;
     public Guid RouteId { get; set; }
     public bool AllowReassignToOtherApprovers { get; set; }
 
-    public Route? Route { get; set; }
+    public TemplateRoute? Route { get; set; }
 }

backend/src/Tnsu.ApprovalRoute.Domain/Enums/HeadType.cs

@@ -0,0 +1,8 @@
+namespace Tnsu.ApprovalRoute.Domain.Enums;
+
+public enum HeadType
+{
+    None,
+    Chief,
+    DirectionHead
+}

backend/src/Tnsu.ApprovalRoute.Domain/Enums/RouteStepStatus.cs

@@ -3,11 +3,6 @@ namespace Tnsu.ApprovalRoute.Domain.Enums;
 public enum RouteStepStatus
 {
     None,
-    Draft,
+    Approval,
-    OnApproval,
+    Execution
-    Approved,
-    InExecution,
-    Completed,
-    Returned,
-    Closed
 }

backend/src/Tnsu.ApprovalRoute.Infrastructure/InfrastructureServiceCollectionExtensions.cs

@@ -2,7 +2,9 @@ using Extensions.Hosting.AsyncInitialization;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using Tnsu.ApprovalRoute.Infrastructure.Persistence;
+using Tnsu.ApprovalRoute.Infrastructure.TnsuPortal;
 
 namespace Tnsu.ApprovalRoute.Infrastructure;
 
@@ -16,6 +18,14 @@ public static class InfrastructureServiceCollectionExtensions
                 .UseSnakeCaseNamingConvention());
         services.AddAsyncInitializer<DatabaseMigrationInitializer>();
 
+        services.Configure<TnsuPortalOptions>(configuration.GetSection("TnsuPortal"));
+        services.AddHttpClient<TnsuPortalTokenProvider>();
+        services.AddHttpClient<HttpTnsuPortalClient>((sp, client) =>
+        {
+            var options = sp.GetRequiredService<IOptions<TnsuPortalOptions>>().Value;
+            client.BaseAddress = new Uri(options.BaseUrl);
+        });
+
         return services;
     }
 }

backend/src/Tnsu.ApprovalRoute.Infrastructure/Persistence/ApprovalRouteDbContext.cs

@@ -6,8 +6,8 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence;
 public class ApprovalRouteDbContext(DbContextOptions<ApprovalRouteDbContext> options) : DbContext(options)
 {
     public DbSet<RequestType> RequestTypes => Set<RequestType>();
-    public DbSet<Route> Routes => Set<Route>();
+    public DbSet<TemplateRoute> TemplateRoutes => Set<TemplateRoute>();
-    public DbSet<RouteStep> RouteSteps => Set<RouteStep>();
+    public DbSet<TemplateRouteStep> TemplateRouteSteps => Set<TemplateRouteStep>();
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
@@ -18,19 +18,21 @@ public class ApprovalRouteDbContext(DbContextOptions<ApprovalRouteDbContext> opt
             e.Property(x => x.PageUrl).HasMaxLength(512).IsRequired();
         });
 
-        modelBuilder.Entity<Route>(e =>
+        modelBuilder.Entity<TemplateRoute>(e =>
         {
             e.HasKey(x => x.Id);
             e.Property(x => x.RouteType).HasConversion<string>().HasMaxLength(32).IsRequired();
             e.HasOne(x => x.RequestType).WithMany(x => x.Routes).HasForeignKey(x => x.RequestTypeId);
+            e.HasIndex(x => new { x.RequestTypeId, x.DepartmentId, x.CompanyId, x.ByProject }).IsUnique();
         });
 
-        modelBuilder.Entity<RouteStep>(e =>
+        modelBuilder.Entity<TemplateRouteStep>(e =>
         {
             e.HasKey(x => x.Id);
             e.Property(x => x.ExecutorEmail).HasMaxLength(256).IsRequired();
             e.Property(x => x.Position).HasMaxLength(128).IsRequired();
             e.Property(x => x.ProjectRole).HasConversion<string>().HasMaxLength(32).IsRequired();
+            e.Property(x => x.HeadType).HasConversion<string>().HasMaxLength(32).IsRequired();
             e.Property(x => x.Status).HasConversion<string>().HasMaxLength(32).IsRequired();
             e.HasOne(x => x.Route).WithMany(x => x.Steps).HasForeignKey(x => x.RouteId);
             e.HasIndex(x => new { x.RouteId, x.OrderNo });

backend/src/Tnsu.ApprovalRoute.Infrastructure/Persistence/Migrations/20260723074943_InitialCreate.Designer.cs

@@ -12,7 +12,7 @@ using Tnsu.ApprovalRoute.Infrastructure.Persistence;
 namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
 {
     [DbContext(typeof(ApprovalRouteDbContext))]
-    [Migration("20260722130455_InitialCreate")]
+    [Migration("20260723074943_InitialCreate")]
     partial class InitialCreate
     {
         /// <inheritdoc />
@@ -50,7 +50,7 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                     b.ToTable("request_types", (string)null);
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.Route", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", b =>
                 {
                     b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
@@ -65,7 +65,7 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnType("uuid")
                         .HasColumnName("company_id");
 
-                    b.Property<Guid>("DepartmentId")
+                    b.Property<Guid?>("DepartmentId")
                         .HasColumnType("uuid")
                         .HasColumnName("department_id");
 
@@ -84,15 +84,16 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnName("route_type");
 
                     b.HasKey("Id")
-                        .HasName("pk_routes");
+                        .HasName("pk_template_routes");
 
-                    b.HasIndex("RequestTypeId")
+                    b.HasIndex("RequestTypeId", "DepartmentId", "CompanyId", "ByProject")
-                        .HasDatabaseName("ix_routes_request_type_id");
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_routes_request_type_id_department_id_company_id_by");
 
-                    b.ToTable("routes", (string)null);
+                    b.ToTable("template_routes", (string)null);
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.RouteStep", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRouteStep", b =>
                 {
                     b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
@@ -109,6 +110,12 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnType("character varying(256)")
                         .HasColumnName("executor_email");
 
+                    b.Property<string>("HeadType")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)")
+                        .HasColumnName("head_type");
+
                     b.Property<int>("OrderNo")
                         .HasColumnType("integer")
                         .HasColumnName("order_no");
@@ -136,34 +143,34 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnName("status");
 
                     b.HasKey("Id")
-                        .HasName("pk_route_steps");
+                        .HasName("pk_template_route_steps");
 
                     b.HasIndex("RouteId", "OrderNo")
-                        .HasDatabaseName("ix_route_steps_route_id_order_no");
+                        .HasDatabaseName("ix_template_route_steps_route_id_order_no");
 
-                    b.ToTable("route_steps", (string)null);
+                    b.ToTable("template_route_steps", (string)null);
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.Route", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", b =>
                 {
                     b.HasOne("Tnsu.ApprovalRoute.Domain.Entities.RequestType", "RequestType")
                         .WithMany("Routes")
                         .HasForeignKey("RequestTypeId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_routes_request_types_request_type_id");
+                        .HasConstraintName("fk_template_routes_request_types_request_type_id");
 
                     b.Navigation("RequestType");
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.RouteStep", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRouteStep", b =>
                 {
-                    b.HasOne("Tnsu.ApprovalRoute.Domain.Entities.Route", "Route")
+                    b.HasOne("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", "Route")
                         .WithMany("Steps")
                         .HasForeignKey("RouteId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_route_steps_routes_route_id");
+                        .HasConstraintName("fk_template_route_steps_template_routes_route_id");
 
                     b.Navigation("Route");
                 });
@@ -173,7 +180,7 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                     b.Navigation("Routes");
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.Route", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", b =>
                 {
                     b.Navigation("Steps");
                 });

backend/src/Tnsu.ApprovalRoute.Infrastructure/Persistence/Migrations/20260723074943_InitialCreate.cs

@@ -25,22 +25,22 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                 });
 
             migrationBuilder.CreateTable(
-                name: "routes",
+                name: "template_routes",
                 columns: table => new
                 {
                     id = table.Column<Guid>(type: "uuid", nullable: false),
                     route_type = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
                     request_type_id = table.Column<Guid>(type: "uuid", nullable: false),
-                    department_id = table.Column<Guid>(type: "uuid", nullable: false),
+                    department_id = table.Column<Guid>(type: "uuid", nullable: true),
                     company_id = table.Column<Guid>(type: "uuid", nullable: false),
                     by_project = table.Column<bool>(type: "boolean", nullable: false),
                     requires_control = table.Column<bool>(type: "boolean", nullable: false)
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("pk_routes", x => x.id);
+                    table.PrimaryKey("pk_template_routes", x => x.id);
                     table.ForeignKey(
-                        name: "fk_routes_request_types_request_type_id",
+                        name: "fk_template_routes_request_types_request_type_id",
                         column: x => x.request_type_id,
                         principalTable: "request_types",
                         principalColumn: "id",
@@ -48,7 +48,7 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                 });
 
             migrationBuilder.CreateTable(
-                name: "route_steps",
+                name: "template_route_steps",
                 columns: table => new
                 {
                     id = table.Column<Guid>(type: "uuid", nullable: false),
@@ -56,40 +56,42 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                     executor_email = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
                     position = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
                     project_role = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
+                    head_type = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
                     status = table.Column<string>(type: "character varying(32)", maxLength: 32, nullable: false),
                     route_id = table.Column<Guid>(type: "uuid", nullable: false),
                     allow_reassign_to_other_approvers = table.Column<bool>(type: "boolean", nullable: false)
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("pk_route_steps", x => x.id);
+                    table.PrimaryKey("pk_template_route_steps", x => x.id);
                     table.ForeignKey(
-                        name: "fk_route_steps_routes_route_id",
+                        name: "fk_template_route_steps_template_routes_route_id",
                         column: x => x.route_id,
-                        principalTable: "routes",
+                        principalTable: "template_routes",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Cascade);
                 });
 
             migrationBuilder.CreateIndex(
-                name: "ix_route_steps_route_id_order_no",
+                name: "ix_template_route_steps_route_id_order_no",
-                table: "route_steps",
+                table: "template_route_steps",
                 columns: new[] { "route_id", "order_no" });
 
             migrationBuilder.CreateIndex(
-                name: "ix_routes_request_type_id",
+                name: "ix_template_routes_request_type_id_department_id_company_id_by",
-                table: "routes",
+                table: "template_routes",
-                column: "request_type_id");
+                columns: new[] { "request_type_id", "department_id", "company_id", "by_project" },
+                unique: true);
         }
 
         /// <inheritdoc />
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropTable(
-                name: "route_steps");
+                name: "template_route_steps");
 
             migrationBuilder.DropTable(
-                name: "routes");
+                name: "template_routes");
 
             migrationBuilder.DropTable(
                 name: "request_types");

backend/src/Tnsu.ApprovalRoute.Infrastructure/Persistence/Migrations/ApprovalRouteDbContextModelSnapshot.cs

@@ -47,7 +47,7 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                     b.ToTable("request_types", (string)null);
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.Route", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", b =>
                 {
                     b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
@@ -62,7 +62,7 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnType("uuid")
                         .HasColumnName("company_id");
 
-                    b.Property<Guid>("DepartmentId")
+                    b.Property<Guid?>("DepartmentId")
                         .HasColumnType("uuid")
                         .HasColumnName("department_id");
 
@@ -81,15 +81,16 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnName("route_type");
 
                     b.HasKey("Id")
-                        .HasName("pk_routes");
+                        .HasName("pk_template_routes");
 
-                    b.HasIndex("RequestTypeId")
+                    b.HasIndex("RequestTypeId", "DepartmentId", "CompanyId", "ByProject")
-                        .HasDatabaseName("ix_routes_request_type_id");
+                        .IsUnique()
+                        .HasDatabaseName("ix_template_routes_request_type_id_department_id_company_id_by");
 
-                    b.ToTable("routes", (string)null);
+                    b.ToTable("template_routes", (string)null);
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.RouteStep", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRouteStep", b =>
                 {
                     b.Property<Guid>("Id")
                         .ValueGeneratedOnAdd()
@@ -106,6 +107,12 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnType("character varying(256)")
                         .HasColumnName("executor_email");
 
+                    b.Property<string>("HeadType")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)")
+                        .HasColumnName("head_type");
+
                     b.Property<int>("OrderNo")
                         .HasColumnType("integer")
                         .HasColumnName("order_no");
@@ -133,34 +140,34 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                         .HasColumnName("status");
 
                     b.HasKey("Id")
-                        .HasName("pk_route_steps");
+                        .HasName("pk_template_route_steps");
 
                     b.HasIndex("RouteId", "OrderNo")
-                        .HasDatabaseName("ix_route_steps_route_id_order_no");
+                        .HasDatabaseName("ix_template_route_steps_route_id_order_no");
 
-                    b.ToTable("route_steps", (string)null);
+                    b.ToTable("template_route_steps", (string)null);
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.Route", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", b =>
                 {
                     b.HasOne("Tnsu.ApprovalRoute.Domain.Entities.RequestType", "RequestType")
                         .WithMany("Routes")
                         .HasForeignKey("RequestTypeId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_routes_request_types_request_type_id");
+                        .HasConstraintName("fk_template_routes_request_types_request_type_id");
 
                     b.Navigation("RequestType");
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.RouteStep", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRouteStep", b =>
                 {
-                    b.HasOne("Tnsu.ApprovalRoute.Domain.Entities.Route", "Route")
+                    b.HasOne("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", "Route")
                         .WithMany("Steps")
                         .HasForeignKey("RouteId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_route_steps_routes_route_id");
+                        .HasConstraintName("fk_template_route_steps_template_routes_route_id");
 
                     b.Navigation("Route");
                 });
@@ -170,7 +177,7 @@ namespace Tnsu.ApprovalRoute.Infrastructure.Persistence.Migrations
                     b.Navigation("Routes");
                 });
 
-            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.Route", b =>
+            modelBuilder.Entity("Tnsu.ApprovalRoute.Domain.Entities.TemplateRoute", b =>
                 {
                     b.Navigation("Steps");
                 });

backend/src/Tnsu.ApprovalRoute.Infrastructure/Tnsu.ApprovalRoute.Infrastructure.csproj

@@ -1,6 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <ItemGroup>
-    <ProjectReference Include="..\Tnsu.ApprovalRoute.Application\Tnsu.ApprovalRoute.Application.csproj" />
     <ProjectReference Include="..\Tnsu.ApprovalRoute.Domain\Tnsu.ApprovalRoute.Domain.csproj" />
   </ItemGroup>
   <ItemGroup>
@@ -12,6 +11,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
+    <PackageReference Include="Microsoft.Extensions.Http" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
   </ItemGroup>
 </Project>

backend/src/Tnsu.ApprovalRoute.Infrastructure/TnsuPortal/HttpTnsuPortalClient.cs

@@ -0,0 +1,20 @@
+namespace Tnsu.ApprovalRoute.Infrastructure.TnsuPortal;
+
+// Клиент api.tnsu.kz (api-tnsu-portal). GetEmployeeByEmailAsync и GetProjectExecutorsAsync — заглушки:
+// на момент написания у api-tnsu-portal нет эндпоинта GET /Employee/ByEmail (есть только ByIIN/Manager),
+// а форма ответа GET /Project/{oid} в его openapi-спеке не типизирована. Заменить на реальные вызовы,
+// когда эндпоинты будут готовы — токен уже прокидывается через TnsuPortalTokenProvider.
+public sealed class HttpTnsuPortalClient(HttpClient httpClient, TnsuPortalTokenProvider tokenProvider)
+{
+    public Task<EmployeeDirectoryInfo> GetEmployeeByEmailAsync(string email, CancellationToken cancellationToken)
+    {
+        return Task.FromResult(new EmployeeDirectoryInfo(
+            DepartmentId: Guid.Parse("00000000-0000-0000-0000-000000000001"),
+            CompanyId: Guid.Parse("00000000-0000-0000-0000-000000000002")));
+    }
+
+    public Task<IReadOnlyList<ProjectExecutorInfo>> GetProjectExecutorsAsync(Guid projectId, CancellationToken cancellationToken)
+    {
+        return Task.FromResult<IReadOnlyList<ProjectExecutorInfo>>([]);
+    }
+}

backend/src/Tnsu.ApprovalRoute.Infrastructure/TnsuPortal/TnsuPortalDtos.cs

@@ -0,0 +1,7 @@
+using Tnsu.ApprovalRoute.Domain.Enums;
+
+namespace Tnsu.ApprovalRoute.Infrastructure.TnsuPortal;
+
+public sealed record EmployeeDirectoryInfo(Guid DepartmentId, Guid CompanyId);
+
+public sealed record ProjectExecutorInfo(string Email, string Position, ProjectRole ProjectRole);

backend/src/Tnsu.ApprovalRoute.Infrastructure/TnsuPortal/TnsuPortalOptions.cs

@@ -0,0 +1,10 @@
+namespace Tnsu.ApprovalRoute.Infrastructure.TnsuPortal;
+
+public sealed class TnsuPortalOptions
+{
+    public string BaseUrl { get; set; } = "https://api.tnsu.kz";
+    public string TenantId { get; set; } = string.Empty;
+    public string ClientId { get; set; } = string.Empty;
+    public string ClientSecret { get; set; } = string.Empty;
+    public string Scope { get; set; } = string.Empty;
+}

backend/src/Tnsu.ApprovalRoute.Infrastructure/TnsuPortal/TnsuPortalTokenProvider.cs

@@ -0,0 +1,43 @@
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.Options;
+
+namespace Tnsu.ApprovalRoute.Infrastructure.TnsuPortal;
+
+// Сервисный (client-credentials) токен для вызова api.tnsu.kz — не связан с токеном конечного пользователя.
+public sealed class TnsuPortalTokenProvider(HttpClient httpClient, IOptions<TnsuPortalOptions> options)
+{
+    private string? _cachedToken;
+    private DateTimeOffset _expiresAt = DateTimeOffset.MinValue;
+
+    public async Task<string> GetAccessTokenAsync(CancellationToken cancellationToken)
+    {
+        if (_cachedToken is not null && DateTimeOffset.UtcNow < _expiresAt)
+            return _cachedToken;
+
+        var opts = options.Value;
+        var response = await httpClient.PostAsync(
+            $"https://login.microsoftonline.com/{opts.TenantId}/oauth2/v2.0/token",
+            new FormUrlEncodedContent(new Dictionary<string, string>
+            {
+                ["grant_type"] = "client_credentials",
+                ["client_id"] = opts.ClientId,
+                ["client_secret"] = opts.ClientSecret,
+                ["scope"] = opts.Scope
+            }),
+            cancellationToken);
+        response.EnsureSuccessStatusCode();
+
+        var payload = await response.Content.ReadFromJsonAsync<TokenResponse>(cancellationToken)
+            ?? throw new InvalidOperationException("Не удалось получить токен для api.tnsu.kz.");
+
+        _cachedToken = payload.AccessToken;
+        _expiresAt = DateTimeOffset.UtcNow.AddSeconds(payload.ExpiresIn - 60);
+
+        return _cachedToken;
+    }
+
+    private sealed record TokenResponse(
+        [property: JsonPropertyName("access_token")] string AccessToken,
+        [property: JsonPropertyName("expires_in")] int ExpiresIn);
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/ApplicationServices/RequestTypeServiceTests.cs

@@ -0,0 +1,98 @@
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Tnsu.ApprovalRoute.Application.RequestTypes;
+using Tnsu.ApprovalRoute.IntegrationTests.Infrastructure;
+
+namespace Tnsu.ApprovalRoute.IntegrationTests.ApplicationServices;
+
+public sealed class RequestTypeServiceTests(PostgresDatabaseFixture fixture) : IClassFixture<PostgresDatabaseFixture>
+{
+    private readonly RequestTypeService _service = TestServiceProviderFactory.Build(fixture.ConnectionString).GetRequiredService<RequestTypeService>();
+
+    [Fact(DisplayName = "Создание типа заявки и получение его по Id возвращает сохранённые данные")]
+    public async Task CreateAsync_Then_GetAsync_ReturnsCreatedEntity()
+    {
+        // Action
+        var created = await _service.CreateAsync(new CreateRequestTypeRequest("Vacation", "/vacation"), CancellationToken.None);
+
+        // Assert
+        created.IsSuccess.ShouldBeTrue();
+        created.Value.Name.ShouldBe("Vacation");
+        created.Value.PageUrl.ShouldBe("/vacation");
+
+        // Action
+        var fetched = await _service.GetAsync(created.Value.Id, CancellationToken.None);
+
+        // Assert
+        fetched.IsSuccess.ShouldBeTrue();
+        fetched.Value.Id.ShouldBe(created.Value.Id);
+        fetched.Value.Name.ShouldBe("Vacation");
+    }
+
+    [Fact(DisplayName = "Получение несуществующего типа заявки возвращает неуспешный результат")]
+    public async Task GetAsync_UnknownId_ReturnsFailedResult()
+    {
+        // Action
+        var result = await _service.GetAsync(Guid.NewGuid(), CancellationToken.None);
+
+        // Assert
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Обновление типа заявки изменяет имя и url страницы")]
+    public async Task UpdateAsync_ChangesFields()
+    {
+        // Arrange
+        var created = await _service.CreateAsync(new CreateRequestTypeRequest("Old name", "/old"), CancellationToken.None);
+
+        // Action
+        var updated = await _service.UpdateAsync(
+            created.Value.Id, new UpdateRequestTypeRequest("New name", "/new"), CancellationToken.None);
+
+        // Assert
+        updated.IsSuccess.ShouldBeTrue();
+        updated.Value.Name.ShouldBe("New name");
+        updated.Value.PageUrl.ShouldBe("/new");
+    }
+
+    [Fact(DisplayName = "Обновление несуществующего типа заявки возвращает неуспешный результат")]
+    public async Task UpdateAsync_UnknownId_ReturnsFailedResult()
+    {
+        // Action
+        var result = await _service.UpdateAsync(
+            Guid.NewGuid(), new UpdateRequestTypeRequest("X", "/x"), CancellationToken.None);
+
+        // Assert
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Удаление типа заявки убирает его из базы")]
+    public async Task DeleteAsync_RemovesEntity()
+    {
+        // Arrange
+        var created = await _service.CreateAsync(new CreateRequestTypeRequest("Temp", "/temp"), CancellationToken.None);
+
+        // Action
+        var deleted = await _service.DeleteAsync(created.Value.Id, CancellationToken.None);
+
+        // Assert
+        deleted.IsSuccess.ShouldBeTrue();
+
+        var fetched = await _service.GetAsync(created.Value.Id, CancellationToken.None);
+        fetched.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Список типов заявок включает ранее созданный тип")]
+    public async Task ListAsync_IncludesCreatedEntity()
+    {
+        // Arrange
+        var created = await _service.CreateAsync(new CreateRequestTypeRequest("Listed type", "/listed"), CancellationToken.None);
+
+        // Action
+        var list = await _service.ListAsync(CancellationToken.None);
+
+        // Assert
+        list.IsSuccess.ShouldBeTrue();
+        list.Value.ShouldContain(x => x.Id == created.Value.Id);
+    }
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/ApplicationServices/TemplateRouteServiceTests.cs

@@ -0,0 +1,175 @@
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Tnsu.ApprovalRoute.Application.RequestTypes;
+using Tnsu.ApprovalRoute.Application.TemplateRoutes;
+using Tnsu.ApprovalRoute.Domain.Enums;
+using Tnsu.ApprovalRoute.IntegrationTests.Infrastructure;
+
+namespace Tnsu.ApprovalRoute.IntegrationTests.ApplicationServices;
+
+public sealed class TemplateRouteServiceTests : IClassFixture<PostgresDatabaseFixture>
+{
+    private static readonly Guid CompanyId = Guid.Parse("00000000-0000-0000-0000-000000000002");
+    private static readonly Guid DepartmentId = Guid.Parse("00000000-0000-0000-0000-000000000001");
+
+    private readonly ServiceProvider _services;
+    private readonly TemplateRouteService _service;
+    private readonly RequestTypeService _requestTypeService;
+
+    public TemplateRouteServiceTests(PostgresDatabaseFixture fixture)
+    {
+        _services = TestServiceProviderFactory.Build(fixture.ConnectionString);
+        _service = _services.GetRequiredService<TemplateRouteService>();
+        _requestTypeService = _services.GetRequiredService<RequestTypeService>();
+    }
+
+    private async Task<Guid> CreateRequestTypeAsync(string name) =>
+        (await _requestTypeService.CreateAsync(new CreateRequestTypeRequest(name, $"/{name}"), CancellationToken.None)).Value.Id;
+
+    [Fact(DisplayName = "Создание маршрута и получение его по Id возвращает сохранённые данные")]
+    public async Task CreateAsync_ThenGetAsync_ReturnsCreatedEntity()
+    {
+        // Arrange
+        var requestTypeId = await CreateRequestTypeAsync("Vacation");
+
+        // Action
+        var created = await _service.CreateAsync(
+            new CreateTemplateRouteRequest(RouteType.Sequential, requestTypeId, DepartmentId, CompanyId, ByProject: false, RequiresControl: true),
+            CancellationToken.None);
+
+        // Assert
+        created.IsSuccess.ShouldBeTrue();
+        created.Value.RequestTypeId.ShouldBe(requestTypeId);
+
+        var fetched = await _service.GetAsync(created.Value.Id, CancellationToken.None);
+        fetched.IsSuccess.ShouldBeTrue();
+        fetched.Value.CompanyId.ShouldBe(CompanyId);
+    }
+
+    [Fact(DisplayName = "Создание маршрута с несуществующим типом заявки возвращает неуспешный результат")]
+    public async Task CreateAsync_UnknownRequestType_ReturnsFailedResult()
+    {
+        // Action
+        var result = await _service.CreateAsync(
+            new CreateTemplateRouteRequest(RouteType.Sequential, Guid.NewGuid(), DepartmentId, CompanyId, ByProject: false, RequiresControl: false),
+            CancellationToken.None);
+
+        // Assert
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Повторное создание маршрута с тем же типом заявки, отделом, компанией и признаком «по проекту» возвращает конфликт")]
+    public async Task CreateAsync_DuplicateRoute_ReturnsFailedResult()
+    {
+        // Arrange
+        var requestTypeId = await CreateRequestTypeAsync("Business trip");
+        var request = new CreateTemplateRouteRequest(RouteType.Sequential, requestTypeId, DepartmentId, CompanyId, ByProject: false, RequiresControl: false);
+        var first = await _service.CreateAsync(request, CancellationToken.None);
+        first.IsSuccess.ShouldBeTrue();
+
+        // Action
+        var duplicate = await _service.CreateAsync(request, CancellationToken.None);
+
+        // Assert
+        duplicate.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Обновление маршрута изменяет тип маршрута и признак необходимости контроля")]
+    public async Task UpdateAsync_ChangesFields()
+    {
+        // Arrange
+        var requestTypeId = await CreateRequestTypeAsync("Sick leave");
+        var created = await _service.CreateAsync(
+            new CreateTemplateRouteRequest(RouteType.Sequential, requestTypeId, DepartmentId, CompanyId, ByProject: false, RequiresControl: false),
+            CancellationToken.None);
+
+        // Action
+        var updated = await _service.UpdateAsync(
+            created.Value.Id,
+            new UpdateTemplateRouteRequest(RouteType.Parallel, DepartmentId, CompanyId, ByProject: false, RequiresControl: true),
+            CancellationToken.None);
+
+        // Assert
+        updated.IsSuccess.ShouldBeTrue();
+        updated.Value.RouteType.ShouldBe(RouteType.Parallel);
+        updated.Value.RequiresControl.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Удаление маршрута убирает его из базы")]
+    public async Task DeleteAsync_RemovesEntity()
+    {
+        // Arrange
+        var requestTypeId = await CreateRequestTypeAsync("Remote work");
+        var created = await _service.CreateAsync(
+            new CreateTemplateRouteRequest(RouteType.Sequential, requestTypeId, DepartmentId, CompanyId, ByProject: false, RequiresControl: false),
+            CancellationToken.None);
+
+        // Action
+        var deleted = await _service.DeleteAsync(created.Value.Id, CancellationToken.None);
+
+        // Assert
+        deleted.IsSuccess.ShouldBeTrue();
+
+        var fetched = await _service.GetAsync(created.Value.Id, CancellationToken.None);
+        fetched.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Резолв маршрута по точному совпадению отдела возвращает шаги с нужным статусом")]
+    public async Task ResolveAsync_ExactDepartmentMatch_ReturnsMatchingStepsForStatus()
+    {
+        // Arrange
+        var requestTypeId = await CreateRequestTypeAsync("Exact match request");
+        var route = await _service.CreateAsync(
+            new CreateTemplateRouteRequest(RouteType.Sequential, requestTypeId, DepartmentId, CompanyId, ByProject: false, RequiresControl: true),
+            CancellationToken.None);
+
+        var stepService = _services.GetRequiredService<Application.TemplateRouteSteps.TemplateRouteStepService>();
+        await stepService.CreateAsync(
+            route.Value.Id,
+            new Application.TemplateRouteSteps.CreateTemplateRouteStepRequest(
+                1, "approver@tnsu.kz", "Lead", ProjectRole.None, HeadType.Chief, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Action
+        var resolved = await _service.ResolveAsync(
+            new ResolveTemplateRouteRequest(requestTypeId, "someone@tnsu.kz", null, RouteStepStatus.Approval),
+            CancellationToken.None);
+
+        // Assert
+        resolved.IsSuccess.ShouldBeTrue();
+        resolved.Value.RouteId.ShouldBe(route.Value.Id);
+        resolved.Value.Steps.ShouldHaveSingleItem();
+        resolved.Value.Steps[0].ExecutorEmail.ShouldBe("approver@tnsu.kz");
+    }
+
+    [Fact(DisplayName = "Резолв маршрута откатывается на маршрут без отдела, если точного совпадения по отделу нет")]
+    public async Task ResolveAsync_NoDepartmentRoute_FallsBackToCompanyWideRoute()
+    {
+        // Arrange
+        var requestTypeId = await CreateRequestTypeAsync("Company-wide request");
+        var route = await _service.CreateAsync(
+            new CreateTemplateRouteRequest(RouteType.Sequential, requestTypeId, DepartmentId: null, CompanyId, ByProject: false, RequiresControl: false),
+            CancellationToken.None);
+
+        // Action
+        var resolved = await _service.ResolveAsync(
+            new ResolveTemplateRouteRequest(requestTypeId, "someone@tnsu.kz", null, RouteStepStatus.Execution),
+            CancellationToken.None);
+
+        // Assert
+        resolved.IsSuccess.ShouldBeTrue();
+        resolved.Value.RouteId.ShouldBe(route.Value.Id);
+    }
+
+    [Fact(DisplayName = "Резолв маршрута с несуществующим типом заявки возвращает неуспешный результат")]
+    public async Task ResolveAsync_UnknownRequestType_ReturnsFailedResult()
+    {
+        // Action
+        var resolved = await _service.ResolveAsync(
+            new ResolveTemplateRouteRequest(Guid.NewGuid(), "someone@tnsu.kz", null, RouteStepStatus.Approval),
+            CancellationToken.None);
+
+        // Assert
+        resolved.IsFailed.ShouldBeTrue();
+    }
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/ApplicationServices/TemplateRouteStepServiceTests.cs

@@ -0,0 +1,165 @@
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Tnsu.ApprovalRoute.Application.RequestTypes;
+using Tnsu.ApprovalRoute.Application.TemplateRoutes;
+using Tnsu.ApprovalRoute.Application.TemplateRouteSteps;
+using Tnsu.ApprovalRoute.Domain.Enums;
+using Tnsu.ApprovalRoute.IntegrationTests.Infrastructure;
+
+namespace Tnsu.ApprovalRoute.IntegrationTests.ApplicationServices;
+
+public sealed class TemplateRouteStepServiceTests : IClassFixture<PostgresDatabaseFixture>
+{
+    private static readonly Guid CompanyId = Guid.Parse("00000000-0000-0000-0000-000000000002");
+
+    private readonly TemplateRouteStepService _service;
+    private readonly TemplateRouteService _routeService;
+    private readonly RequestTypeService _requestTypeService;
+
+    public TemplateRouteStepServiceTests(PostgresDatabaseFixture fixture)
+    {
+        var services = TestServiceProviderFactory.Build(fixture.ConnectionString);
+        _service = services.GetRequiredService<TemplateRouteStepService>();
+        _routeService = services.GetRequiredService<TemplateRouteService>();
+        _requestTypeService = services.GetRequiredService<RequestTypeService>();
+    }
+
+    private async Task<Guid> CreateRouteAsync(string requestTypeName, bool byProject)
+    {
+        var requestTypeId = (await _requestTypeService.CreateAsync(
+            new CreateRequestTypeRequest(requestTypeName, $"/{requestTypeName}"), CancellationToken.None)).Value.Id;
+
+        var route = await _routeService.CreateAsync(
+            new CreateTemplateRouteRequest(RouteType.Sequential, requestTypeId, null, CompanyId, byProject, RequiresControl: false),
+            CancellationToken.None);
+
+        return route.Value.Id;
+    }
+
+    [Fact(DisplayName = "Создание шага для несуществующего маршрута возвращает неуспешный результат")]
+    public async Task CreateAsync_UnknownRoute_ReturnsFailedResult()
+    {
+        // Action
+        var result = await _service.CreateAsync(
+            Guid.NewGuid(),
+            new CreateTemplateRouteStepRequest(1, "a@b.kz", "Engineer", ProjectRole.None, HeadType.None, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Assert
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Роль в проекте недопустима для шага маршрута без признака «по проекту»")]
+    public async Task CreateAsync_ProjectRoleOnNonProjectRoute_ReturnsFailedResult()
+    {
+        // Arrange
+        var routeId = await CreateRouteAsync("Non project route", byProject: false);
+
+        // Action
+        var result = await _service.CreateAsync(
+            routeId,
+            new CreateTemplateRouteStepRequest(1, "a@b.kz", "Engineer", ProjectRole.Manager, HeadType.None, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Assert
+        result.IsFailed.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Создание шага маршрута и получение его по Id возвращает сохранённые данные")]
+    public async Task CreateAsync_ThenGetAsync_ReturnsCreatedStep()
+    {
+        // Arrange
+        var routeId = await CreateRouteAsync("Simple route", byProject: false);
+
+        // Action
+        var created = await _service.CreateAsync(
+            routeId,
+            new CreateTemplateRouteStepRequest(1, "a@b.kz", "Engineer", ProjectRole.None, HeadType.None, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Assert
+        created.IsSuccess.ShouldBeTrue();
+
+        var fetched = await _service.GetAsync(routeId, created.Value.Id, CancellationToken.None);
+        fetched.IsSuccess.ShouldBeTrue();
+        fetched.Value.ExecutorEmail.ShouldBe("a@b.kz");
+    }
+
+    [Fact(DisplayName = "Создание шага без роли в проекте на маршруте «по проекту» возвращает предупреждение")]
+    public async Task CreateAsync_ByProjectRouteWithoutProjectRoleStep_ReturnsWarning()
+    {
+        // Arrange
+        var routeId = await CreateRouteAsync("By-project route without role", byProject: true);
+
+        // Action
+        var created = await _service.CreateAsync(
+            routeId,
+            new CreateTemplateRouteStepRequest(1, "a@b.kz", "Engineer", ProjectRole.None, HeadType.None, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Assert
+        created.IsSuccess.ShouldBeTrue();
+        created.Reasons.ShouldContain(r => r.Message.Contains("ролью в проекте"));
+    }
+
+    [Fact(DisplayName = "Создание шага с ролью в проекте на маршруте «по проекту» не возвращает предупреждение")]
+    public async Task CreateAsync_ByProjectRouteWithProjectRoleStep_HasNoWarning()
+    {
+        // Arrange
+        var routeId = await CreateRouteAsync("By-project route with role", byProject: true);
+
+        // Action
+        var created = await _service.CreateAsync(
+            routeId,
+            new CreateTemplateRouteStepRequest(1, "", "", ProjectRole.Manager, HeadType.None, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Assert
+        created.IsSuccess.ShouldBeTrue();
+        created.Reasons.ShouldBeEmpty();
+    }
+
+    [Fact(DisplayName = "Обновление шага маршрута изменяет исполнителя, статус и разрешение на переназначение")]
+    public async Task UpdateAsync_ChangesFields()
+    {
+        // Arrange
+        var routeId = await CreateRouteAsync("Route to update step", byProject: false);
+        var created = await _service.CreateAsync(
+            routeId,
+            new CreateTemplateRouteStepRequest(1, "a@b.kz", "Engineer", ProjectRole.None, HeadType.None, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Action
+        var updated = await _service.UpdateAsync(
+            routeId,
+            created.Value.Id,
+            new UpdateTemplateRouteStepRequest(2, "b@b.kz", "Senior Engineer", ProjectRole.None, HeadType.Chief, RouteStepStatus.Execution, true),
+            CancellationToken.None);
+
+        // Assert
+        updated.IsSuccess.ShouldBeTrue();
+        updated.Value.ExecutorEmail.ShouldBe("b@b.kz");
+        updated.Value.Status.ShouldBe(RouteStepStatus.Execution);
+        updated.Value.AllowReassignToOtherApprovers.ShouldBeTrue();
+    }
+
+    [Fact(DisplayName = "Удаление шага маршрута убирает его из базы")]
+    public async Task DeleteAsync_RemovesStep()
+    {
+        // Arrange
+        var routeId = await CreateRouteAsync("Route to delete step", byProject: false);
+        var created = await _service.CreateAsync(
+            routeId,
+            new CreateTemplateRouteStepRequest(1, "a@b.kz", "Engineer", ProjectRole.None, HeadType.None, RouteStepStatus.Approval, false),
+            CancellationToken.None);
+
+        // Action
+        var deleted = await _service.DeleteAsync(routeId, created.Value.Id, CancellationToken.None);
+
+        // Assert
+        deleted.IsSuccess.ShouldBeTrue();
+
+        var fetched = await _service.GetAsync(routeId, created.Value.Id, CancellationToken.None);
+        fetched.IsFailed.ShouldBeTrue();
+    }
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/Infrastructure/PostgresDatabaseFixture.cs

@@ -0,0 +1,59 @@
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using Tnsu.ApprovalRoute.Infrastructure.Persistence;
+using Xunit;
+
+namespace Tnsu.ApprovalRoute.IntegrationTests.Infrastructure;
+
+// Отдельная БД на один xUnit-collection (= один тестовый класс) в общем инстансе Postgres.
+// Тесты внутри класса делят эту БД; разные классы (разные коллекции) получают разные БД.
+public sealed class PostgresDatabaseFixture : IAsyncLifetime
+{
+    private readonly string _databaseName = $"tnsu_test_{Guid.NewGuid():N}";
+    private readonly NpgsqlConnectionStringBuilder _adminConnectionBuilder = new(TestSettings.BaseConnectionString);
+
+    public string ConnectionString { get; private set; } = string.Empty;
+
+    public async Task InitializeAsync()
+    {
+        await using (var adminConnection = new NpgsqlConnection(_adminConnectionBuilder.ConnectionString))
+        {
+            await adminConnection.OpenAsync();
+            await using var createCommand = new NpgsqlCommand($"CREATE DATABASE \"{_databaseName}\"", adminConnection);
+            await createCommand.ExecuteNonQueryAsync();
+        }
+
+        ConnectionString = new NpgsqlConnectionStringBuilder(_adminConnectionBuilder.ConnectionString)
+        {
+            Database = _databaseName
+        }.ConnectionString;
+
+        var options = new DbContextOptionsBuilder<ApprovalRouteDbContext>()
+            .UseNpgsql(ConnectionString)
+            .UseSnakeCaseNamingConvention()
+            .Options;
+
+        await using var db = new ApprovalRouteDbContext(options);
+        await db.Database.MigrateAsync();
+    }
+
+    public async Task DisposeAsync()
+    {
+        await using var adminConnection = new NpgsqlConnection(_adminConnectionBuilder.ConnectionString);
+        await adminConnection.OpenAsync();
+
+        await using (var terminateCommand = new NpgsqlCommand(
+            """
+            SELECT pg_terminate_backend(pid) FROM pg_stat_activity
+            WHERE datname = @databaseName AND pid <> pg_backend_pid();
+            """,
+            adminConnection))
+        {
+            terminateCommand.Parameters.AddWithValue("databaseName", _databaseName);
+            await terminateCommand.ExecuteNonQueryAsync();
+        }
+
+        await using var dropCommand = new NpgsqlCommand($"DROP DATABASE IF EXISTS \"{_databaseName}\"", adminConnection);
+        await dropCommand.ExecuteNonQueryAsync();
+    }
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/Infrastructure/TestCurrentUser.cs

@@ -0,0 +1,8 @@
+using Tnsu.ApprovalRoute.Application.Common.Interfaces;
+
+namespace Tnsu.ApprovalRoute.IntegrationTests.Infrastructure;
+
+internal sealed class TestCurrentUser(string? email = null) : ICurrentUser
+{
+    public string? Email { get; } = email;
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/Infrastructure/TestServiceProviderFactory.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Tnsu.ApprovalRoute.Application;
+using Tnsu.ApprovalRoute.Application.Common.Interfaces;
+using Tnsu.ApprovalRoute.Infrastructure;
+
+namespace Tnsu.ApprovalRoute.IntegrationTests.Infrastructure;
+
+// Собирает такой же DI-контейнер, как реальное приложение (те же extension-методы, что в Program.cs),
+// но с тестовой БД и тестовым ICurrentUser вместо HttpContext-based реализации.
+internal static class TestServiceProviderFactory
+{
+    public static ServiceProvider Build(string connectionString, string? currentUserEmail = "initiator@tnsu.kz")
+    {
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["ConnectionStrings:Postgres"] = connectionString
+            })
+            .Build();
+
+        var services = new ServiceCollection();
+        services.AddApprovalRouteInfrastructure(configuration);
+        services.AddApprovalRouteApplication();
+        services.AddSingleton<ICurrentUser>(new TestCurrentUser(currentUserEmail));
+
+        return services.BuildServiceProvider();
+    }
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/Infrastructure/TestSettings.cs

@@ -0,0 +1,8 @@
+namespace Tnsu.ApprovalRoute.IntegrationTests.Infrastructure;
+
+internal static class TestSettings
+{
+    public static string BaseConnectionString =>
+        Environment.GetEnvironmentVariable("TEST_POSTGRES_CONNECTION")
+        ?? "Host=localhost;Port=5435;Database=tnsu_approval_route;Username=tnsu_approval_route;Password=tnsu_approval_route";
+}

backend/tests/Tnsu.ApprovalRoute.IntegrationTests/Tnsu.ApprovalRoute.IntegrationTests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Tnsu.ApprovalRoute.Infrastructure\Tnsu.ApprovalRoute.Infrastructure.csproj" />
+    <ProjectReference Include="..\..\src\Tnsu.ApprovalRoute.Application\Tnsu.ApprovalRoute.Application.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" />
+    <PackageReference Include="Microsoft.Extensions.Configuration" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+    <PackageReference Include="Shouldly" />
+    <PackageReference Include="xunit" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>