Add settings endpoints and registration status check: implement new API endpoints for settings management, including registration status retrieval, and update the registration command handler to enforce registration rules based on site settings.

backend/src/TeleWave.Api/Endpoints/AuthEndpoints.cs

@@ -9,6 +9,7 @@ using TeleWave.Application.Auth.Logout;
 using TeleWave.Application.Auth.Me;
 using TeleWave.Application.Auth.Refresh;
 using TeleWave.Application.Auth.Register;
+using TeleWave.Application.Settings.GetSiteSettings;
 
 namespace TeleWave.Api.Endpoints;
 
@@ -22,6 +23,7 @@ public static class AuthEndpoints
             .WithTags("Auth")
             .RequireRateLimiting(RateLimiting.AuthPolicy);
 
+        group.MapGet("/registration", RegistrationStatus).Produces<RegistrationStatusDto>();
         group.MapPost("/register", Register).Produces<AuthResponseDto>();
         group.MapPost("/login", Login).Produces<AuthResponseDto>();
         group.MapPost("/refresh", Refresh).Produces<AuthResponseDto>();
@@ -46,6 +48,15 @@ public static class AuthEndpoints
         return app;
     }
 
+    private static async Task<IResult> RegistrationStatus(
+        ISender sender,
+        CancellationToken cancellationToken
+    )
+    {
+        var settings = await sender.Send(new GetSiteSettingsQuery(), cancellationToken);
+        return Results.Ok(new RegistrationStatusDto(settings.RegistrationEnabled));
+    }
+
     private static async Task<IResult> Register(
         RegisterCommand command,
         ISender sender,
@@ -218,3 +229,6 @@ public sealed record AuthResponseDto(
     DateTimeOffset ExpiresAt,
     CurrentUserDto User
 );
+
+/// <summary>Публичный ответ: включена ли открытая регистрация (для страниц входа/регистрации).</summary>
+public sealed record RegistrationStatusDto(bool Enabled);

backend/src/TeleWave.Api/Endpoints/SettingsEndpoints.cs

@@ -0,0 +1,44 @@
+using LiteCqrs;
+using TeleWave.Api.Common;
+using TeleWave.Application.Settings;
+using TeleWave.Application.Settings.GetSiteSettings;
+using TeleWave.Application.Settings.UpdateSiteSettings;
+using TeleWave.Infrastructure.Identity;
+
+namespace TeleWave.Api.Endpoints;
+
+public static class SettingsEndpoints
+{
+    public static IEndpointRouteBuilder MapSettingsEndpoints(this IEndpointRouteBuilder app)
+    {
+        var admin = app.MapGroup("/api/admin/settings")
+            .WithTags("Admin.Settings")
+            .RequireAuthorization(policy => policy.RequireRole(RoleNames.Admin));
+
+        admin.MapGet("", GetSettings).Produces<SiteSettingsDto>();
+        admin.MapPut("", UpdateSettings).Produces(StatusCodes.Status204NoContent);
+
+        return app;
+    }
+
+    private static async Task<IResult> GetSettings(ISender sender, CancellationToken cancellationToken)
+    {
+        var settings = await sender.Send(new GetSiteSettingsQuery(), cancellationToken);
+        return Results.Ok(settings);
+    }
+
+    private static async Task<IResult> UpdateSettings(
+        UpdateSiteSettingsBody body,
+        ISender sender,
+        CancellationToken cancellationToken
+    )
+    {
+        var result = await sender.Send(
+            new UpdateSiteSettingsCommand(body.RegistrationEnabled),
+            cancellationToken
+        );
+        return result.ToHttpResult();
+    }
+}
+
+public sealed record UpdateSiteSettingsBody(bool RegistrationEnabled);

backend/src/TeleWave.Api/Program.cs

@@ -117,6 +117,7 @@ app.MapShowEndpoints();
 app.MapChannelEndpoints();
 app.MapStreamingEndpoints();
 app.MapMaintenanceEndpoints();
+app.MapSettingsEndpoints();
 
 // Раздача статики SPA из wwwroot + fallback на index.html для клиентских маршрутов.
 app.UseDefaultFiles();

backend/src/TeleWave.Application/Auth/AuthErrors.cs

@@ -26,4 +26,9 @@ public static class AuthErrors
         "Auth.UserNameTaken",
         "Это имя пользователя уже занято."
     );
+
+    public static readonly Error RegistrationDisabled = Error.Forbidden(
+        "Auth.RegistrationDisabled",
+        "Регистрация на сайте отключена администратором."
+    );
 }

backend/src/TeleWave.Application/Auth/Register/RegisterCommandHandler.cs

@@ -7,7 +7,8 @@ namespace TeleWave.Application.Auth.Register;
 public sealed class RegisterCommandHandler(
     IIdentityService identityService,
     IJwtTokenService jwtTokenService,
-    IRefreshTokenService refreshTokenService
+    IRefreshTokenService refreshTokenService,
+    ISiteSettings siteSettings
 ) : ICommandHandler<RegisterCommand, Result<AuthResult>>
 {
     public async Task<Result<AuthResult>> Handle(
@@ -15,6 +16,10 @@ public sealed class RegisterCommandHandler(
         CancellationToken cancellationToken
     )
     {
+        // Открытая регистрация должна быть явно включена админом; иначе учётки заводит только он.
+        if (!await siteSettings.IsRegistrationEnabledAsync(cancellationToken))
+            return Result.Failure<AuthResult>(AuthErrors.RegistrationDisabled);
+
         var createResult = await identityService.CreateUserAsync(
             command.UserName,
             command.Password,

backend/src/TeleWave.Application/Common/Interfaces/IAppDbContext.cs

@@ -3,6 +3,7 @@ using TeleWave.Domain.Auth;
 using TeleWave.Domain.Broadcast;
 using TeleWave.Domain.Library;
 using TeleWave.Domain.Media;
+using TeleWave.Domain.Settings;
 
 namespace TeleWave.Application.Common.Interfaces;
 
@@ -14,6 +15,7 @@ public interface IAppDbContext
     DbSet<Channel> Channels { get; }
     DbSet<ScheduleEntry> ScheduleEntries { get; }
     DbSet<BumperAsset> BumperAssets { get; }
+    DbSet<AppSetting> AppSettings { get; }
 
     Task<int> SaveChangesAsync(CancellationToken cancellationToken);
 }

backend/src/TeleWave.Application/Common/Interfaces/ISiteSettings.cs

@@ -0,0 +1,10 @@
+namespace TeleWave.Application.Common.Interfaces;
+
+/// <summary>Доступ к глобальным настройкам сайта (key-value), скрывающий хранилище от хендлеров.</summary>
+public interface ISiteSettings
+{
+    Task<bool> IsRegistrationEnabledAsync(CancellationToken cancellationToken);
+
+    /// <summary>Пишет значение в контекст (сохранение — за UnitOfWorkBehavior вызывающей команды).</summary>
+    Task SetRegistrationEnabledAsync(bool enabled, CancellationToken cancellationToken);
+}

backend/src/TeleWave.Application/Settings/AppSettingsReader.cs

@@ -0,0 +1,23 @@
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Common.Interfaces;
+
+namespace TeleWave.Application.Settings;
+
+/// <summary>Чтение типизированных значений из key-value настроек с дефолтом при отсутствии ключа.</summary>
+public static class AppSettingsReader
+{
+    public static async Task<bool> GetBoolSettingAsync(
+        this IAppDbContext db,
+        string key,
+        bool defaultValue,
+        CancellationToken cancellationToken
+    )
+    {
+        var value = await db.AppSettings.AsNoTracking()
+            .Where(s => s.Key == key)
+            .Select(s => s.Value)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        return value is not null && bool.TryParse(value, out var parsed) ? parsed : defaultValue;
+    }
+}

backend/src/TeleWave.Application/Settings/GetSiteSettings/GetSiteSettingsQuery.cs

@@ -0,0 +1,5 @@
+using LiteCqrs;
+
+namespace TeleWave.Application.Settings.GetSiteSettings;
+
+public sealed record GetSiteSettingsQuery : IQuery<SiteSettingsDto>;

backend/src/TeleWave.Application/Settings/GetSiteSettings/GetSiteSettingsQueryHandler.cs

@@ -0,0 +1,17 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Interfaces;
+
+namespace TeleWave.Application.Settings.GetSiteSettings;
+
+public sealed class GetSiteSettingsQueryHandler(ISiteSettings siteSettings)
+    : IQueryHandler<GetSiteSettingsQuery, SiteSettingsDto>
+{
+    public async Task<SiteSettingsDto> Handle(
+        GetSiteSettingsQuery query,
+        CancellationToken cancellationToken
+    )
+    {
+        var registrationEnabled = await siteSettings.IsRegistrationEnabledAsync(cancellationToken);
+        return new SiteSettingsDto(registrationEnabled);
+    }
+}

backend/src/TeleWave.Application/Settings/SettingKeys.cs

@@ -0,0 +1,8 @@
+namespace TeleWave.Application.Settings;
+
+/// <summary>Стабильные ключи глобальных настроек сайта в key-value хранилище (AppSetting).</summary>
+public static class SettingKeys
+{
+    /// <summary>Разрешена ли открытая регистрация пользователей (по умолчанию — нет).</summary>
+    public const string RegistrationEnabled = "registration.enabled";
+}

backend/src/TeleWave.Application/Settings/SiteSettingsDto.cs

@@ -0,0 +1,4 @@
+namespace TeleWave.Application.Settings;
+
+/// <summary>Глобальные настройки сайта, управляемые администратором.</summary>
+public sealed record SiteSettingsDto(bool RegistrationEnabled);

backend/src/TeleWave.Application/Settings/UpdateSiteSettings/UpdateSiteSettingsCommand.cs

@@ -0,0 +1,6 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Settings.UpdateSiteSettings;
+
+public sealed record UpdateSiteSettingsCommand(bool RegistrationEnabled) : ICommand<Result>;

backend/src/TeleWave.Application/Settings/UpdateSiteSettings/UpdateSiteSettingsCommandHandler.cs

@@ -0,0 +1,19 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Settings.UpdateSiteSettings;
+
+public sealed class UpdateSiteSettingsCommandHandler(ISiteSettings siteSettings)
+    : ICommandHandler<UpdateSiteSettingsCommand, Result>
+{
+    public async Task<Result> Handle(
+        UpdateSiteSettingsCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        // Сохранение выполняет UnitOfWorkBehavior команды.
+        await siteSettings.SetRegistrationEnabledAsync(command.RegistrationEnabled, cancellationToken);
+        return Result.Success();
+    }
+}

backend/src/TeleWave.Domain/Settings/AppSetting.cs

@@ -0,0 +1,19 @@
+namespace TeleWave.Domain.Settings;
+
+/// <summary>
+/// Простое key-value хранилище настроек сайта (единичные глобальные флаги/значения, которые админ
+/// меняет в рантайме). Ключ — стабильный строковый идентификатор; значение — строка (парсится
+/// потребителем). Отсутствие ключа трактуется как значение по умолчанию.
+/// </summary>
+public class AppSetting
+{
+    public string Key { get; private set; } = string.Empty;
+    public string Value { get; private set; } = string.Empty;
+
+    private AppSetting() { }
+
+    public static AppSetting Create(string key, string value) =>
+        new() { Key = key, Value = value };
+
+    public void SetValue(string value) => Value = value;
+}

backend/src/TeleWave.Infrastructure/DependencyInjection.cs

@@ -14,6 +14,7 @@ using TeleWave.Infrastructure.Broadcast;
 using TeleWave.Infrastructure.Identity;
 using TeleWave.Infrastructure.Media;
 using TeleWave.Infrastructure.Persistence;
+using TeleWave.Infrastructure.Settings;
 using TeleWave.Infrastructure.Streaming;
 
 namespace TeleWave.Infrastructure;
@@ -90,6 +91,7 @@ public static class DependencyInjection
         services.AddScoped<IRefreshTokenService, RefreshTokenService>();
         services.AddScoped<IRoleService, RoleService>();
         services.AddScoped<ICurrentUser, CurrentUser>();
+        services.AddScoped<ISiteSettings, SiteSettings>();
         services.AddScoped<DbInitializer>();
 
         AddMedia(services, configuration);

backend/src/TeleWave.Infrastructure/Migrations/20260725041827_AppSettings.Designer.cs

@@ -0,0 +1,812 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using TeleWave.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace TeleWave.Infrastructure.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260725041827_AppSettings")]
+    partial class AppSettings
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.10")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Auth.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReplacedByTokenHash")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.BumperAsset", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("FromShowId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MediaAssetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Signature")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid>("ToShowId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FromShowId", "ToShowId", "Signature");
+
+                    b.ToTable("BumperAssets");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.Channel", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AdInsertion")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AdsPerBreak")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BumperAccentColor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BumperBackgroundColor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BumperBackgroundColor2")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BumperBackgroundExtension")
+                        .HasColumnType("text");
+
+                    b.Property<int>("BumperDurationSeconds")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("BumperFont")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("BumperMinIntervalMinutes")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("BumperMode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BumperMusicExtension")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BumperNextLabel")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BumperNowLabel")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("BumperOnlyBetweenDifferentShows")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("BumperRevision")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BumperTextColor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("BumpersEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("EpochUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("FillerAssetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int>("NextAdIndex")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("NextJingleIndex")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Channels");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ChannelAd", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChannelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MediaAssetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId", "Position");
+
+                    b.ToTable("ChannelAd");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ChannelJingle", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChannelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("MediaAssetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId", "Position");
+
+                    b.ToTable("ChannelJingle");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ChannelShow", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("BlockMode")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("BlockValue")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ChannelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("NextEpisodeIndex")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ShowId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Weight")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId", "ShowId");
+
+                    b.ToTable("ChannelShow");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.OverrideShow", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ProgrammingOverrideId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ShowId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Weight")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProgrammingOverrideId");
+
+                    b.ToTable("OverrideShow");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ProgrammingOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChannelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("EndsAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Mode")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("StartsAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId", "StartsAtUtc", "EndsAtUtc");
+
+                    b.ToTable("ProgrammingOverride");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ScheduleEntry", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ChannelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("EndsAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("EpisodeIndex")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("MediaAssetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ShowId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("StartsAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId", "EndsAtUtc");
+
+                    b.HasIndex("ChannelId", "ShowId");
+
+                    b.HasIndex("ChannelId", "StartsAtUtc");
+
+                    b.ToTable("ScheduleEntries");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Library.Show", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Shows");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Library.ShowEpisode", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("MediaAssetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Position")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ShowId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaAssetId");
+
+                    b.HasIndex("ShowId", "Position");
+
+                    b.ToTable("ShowEpisode");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Media.MediaAsset", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AudioCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<TimeSpan?>("Duration")
+                        .HasColumnType("interval");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("OriginalExtension")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<string>("OriginalFileName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("RelativePath")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("SegmentCount")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SegmentSeconds")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("VideoCodec")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("MediaAssets");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Settings.AppSetting", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("AppSettings");
+                });
+
+            modelBuilder.Entity("TeleWave.Infrastructure.Identity.AppRole", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("TeleWave.Infrastructure.Identity.AppUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsBlocked")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.HasOne("TeleWave.Infrastructure.Identity.AppRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.HasOne("TeleWave.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.HasOne("TeleWave.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.HasOne("TeleWave.Infrastructure.Identity.AppRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("TeleWave.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.HasOne("TeleWave.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ChannelAd", b =>
+                {
+                    b.HasOne("TeleWave.Domain.Broadcast.Channel", null)
+                        .WithMany("Ads")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ChannelJingle", b =>
+                {
+                    b.HasOne("TeleWave.Domain.Broadcast.Channel", null)
+                        .WithMany("Jingles")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ChannelShow", b =>
+                {
+                    b.HasOne("TeleWave.Domain.Broadcast.Channel", null)
+                        .WithMany("Shows")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.OverrideShow", b =>
+                {
+                    b.HasOne("TeleWave.Domain.Broadcast.ProgrammingOverride", null)
+                        .WithMany("Shows")
+                        .HasForeignKey("ProgrammingOverrideId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ProgrammingOverride", b =>
+                {
+                    b.HasOne("TeleWave.Domain.Broadcast.Channel", null)
+                        .WithMany("Overrides")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Library.ShowEpisode", b =>
+                {
+                    b.HasOne("TeleWave.Domain.Library.Show", null)
+                        .WithMany("Episodes")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.Channel", b =>
+                {
+                    b.Navigation("Ads");
+
+                    b.Navigation("Jingles");
+
+                    b.Navigation("Overrides");
+
+                    b.Navigation("Shows");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Broadcast.ProgrammingOverride", b =>
+                {
+                    b.Navigation("Shows");
+                });
+
+            modelBuilder.Entity("TeleWave.Domain.Library.Show", b =>
+                {
+                    b.Navigation("Episodes");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/src/TeleWave.Infrastructure/Migrations/20260725041827_AppSettings.cs

@@ -0,0 +1,33 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TeleWave.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class AppSettings : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "AppSettings",
+                columns: table => new
+                {
+                    Key = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    Value = table.Column<string>(type: "character varying(1024)", maxLength: 1024, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AppSettings", x => x.Key);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AppSettings");
+        }
+    }
+}

backend/src/TeleWave.Infrastructure/Migrations/AppDbContextModelSnapshot.cs

@@ -561,6 +561,22 @@ namespace TeleWave.Infrastructure.Migrations
                     b.ToTable("MediaAssets");
                 });
 
+            modelBuilder.Entity("TeleWave.Domain.Settings.AppSetting", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("AppSettings");
+                });
+
             modelBuilder.Entity("TeleWave.Infrastructure.Identity.AppRole", b =>
                 {
                     b.Property<Guid>("Id")

backend/src/TeleWave.Infrastructure/Persistence/AppDbContext.cs

@@ -6,6 +6,7 @@ using TeleWave.Domain.Auth;
 using TeleWave.Domain.Broadcast;
 using TeleWave.Domain.Library;
 using TeleWave.Domain.Media;
+using TeleWave.Domain.Settings;
 using TeleWave.Infrastructure.Identity;
 
 namespace TeleWave.Infrastructure.Persistence;
@@ -24,6 +25,7 @@ public class AppDbContext(DbContextOptions<AppDbContext> options)
     public DbSet<Channel> Channels => Set<Channel>();
     public DbSet<ScheduleEntry> ScheduleEntries => Set<ScheduleEntry>();
     public DbSet<BumperAsset> BumperAssets => Set<BumperAsset>();
+    public DbSet<AppSetting> AppSettings => Set<AppSetting>();
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {

backend/src/TeleWave.Infrastructure/Persistence/Configurations/AppSettingConfiguration.cs

@@ -0,0 +1,15 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using TeleWave.Domain.Settings;
+
+namespace TeleWave.Infrastructure.Persistence.Configurations;
+
+public class AppSettingConfiguration : IEntityTypeConfiguration<AppSetting>
+{
+    public void Configure(EntityTypeBuilder<AppSetting> builder)
+    {
+        builder.HasKey(x => x.Key);
+        builder.Property(x => x.Key).HasMaxLength(128);
+        builder.Property(x => x.Value).IsRequired().HasMaxLength(1024);
+    }
+}

backend/src/TeleWave.Infrastructure/Settings/SiteSettings.cs

@@ -0,0 +1,27 @@
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Settings;
+using TeleWave.Domain.Settings;
+
+namespace TeleWave.Infrastructure.Settings;
+
+/// <summary>Настройки сайта поверх key-value таблицы AppSetting. Запись не сохраняет сама —
+/// сохранение выполняет UnitOfWorkBehavior команды (используется общий scoped-контекст).</summary>
+public sealed class SiteSettings(IAppDbContext dbContext) : ISiteSettings
+{
+    public Task<bool> IsRegistrationEnabledAsync(CancellationToken cancellationToken) =>
+        dbContext.GetBoolSettingAsync(SettingKeys.RegistrationEnabled, false, cancellationToken);
+
+    public async Task SetRegistrationEnabledAsync(bool enabled, CancellationToken cancellationToken)
+    {
+        var value = enabled ? "true" : "false";
+        var existing = await dbContext.AppSettings.FirstOrDefaultAsync(
+            s => s.Key == SettingKeys.RegistrationEnabled,
+            cancellationToken
+        );
+        if (existing is null)
+            dbContext.AppSettings.Add(AppSetting.Create(SettingKeys.RegistrationEnabled, value));
+        else
+            existing.SetValue(value);
+    }
+}

backend/tests/TeleWave.Application.Tests/Auth/RegisterCommandHandlerTests.cs

@@ -13,9 +13,15 @@ public class RegisterCommandHandlerTests
     private readonly IJwtTokenService _jwtTokenService = Substitute.For<IJwtTokenService>();
     private readonly IRefreshTokenService _refreshTokenService =
         Substitute.For<IRefreshTokenService>();
+    private readonly ISiteSettings _siteSettings = Substitute.For<ISiteSettings>();
+
+    public RegisterCommandHandlerTests()
+    {
+        _siteSettings.IsRegistrationEnabledAsync(Arg.Any<CancellationToken>()).Returns(true);
+    }
 
     private RegisterCommandHandler CreateHandler() =>
-        new(_identityService, _jwtTokenService, _refreshTokenService);
+        new(_identityService, _jwtTokenService, _refreshTokenService, _siteSettings);
 
     [Fact]
     public async Task Handle_WithNewUserName_CreatesUserAndReturnsAuthResult()
@@ -41,6 +47,21 @@ public class RegisterCommandHandlerTests
         Assert.Equal("bob", result.Value.User.UserName);
     }
 
+    [Fact]
+    public async Task Handle_WhenRegistrationDisabled_ReturnsForbidden()
+    {
+        _siteSettings.IsRegistrationEnabledAsync(Arg.Any<CancellationToken>()).Returns(false);
+
+        var result = await CreateHandler()
+            .Handle(new RegisterCommand("bob", "password123"), CancellationToken.None);
+
+        Assert.False(result.IsSuccess);
+        Assert.Equal(AuthErrors.RegistrationDisabled, result.Error);
+        await _identityService
+            .DidNotReceive()
+            .CreateUserAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>());
+    }
+
     [Fact]
     public async Task Handle_WithTakenUserName_ReturnsFailure()
     {