Enhance template and scheduling functionalities: add PlanningRules to template endpoints and commands, implement repeat limits and audience filtering in scheduling logic, and update related data structures. Refactor frontend components to support new rules and improve user experience in channel management.

backend/src/TeleWave.Application/Programming/Planning/GridScheduleGenerator.cs

@@ -258,7 +258,19 @@ public sealed class GridScheduleGenerator(
             .Distinct()
             .ToList();
 
-        var elementsByGroup = await expander.ExpandAsync(groupIds, channel.Id, cancellationToken);
+        // Правила канала: детское время резолвится на каждый слот по его времени, а под потолок
+        // повторов нужна история показов — её глубина и задаётся окном правила.
+        var rules = PlanningRules.FromJson(template.RulesJson);
+        var repeatLimit = rules?.MaxRepeatsInWindow is { WindowDays: > 0, Max: > 0 } limit
+            ? new RepeatLimit(limit.WindowDays, limit.Max)
+            : null;
+
+        var elementsByGroup = await expander.ExpandAsync(
+            groupIds,
+            channel.Id,
+            cancellationToken,
+            repeatLimit is null ? null : startUtc.AddDays(-repeatLimit.WindowDays)
+        );
 
         var slotIds = scheduled.Select(s => s.Slot.Id).Distinct().ToList();
         var states = await dbContext
@@ -308,7 +320,13 @@ public sealed class GridScheduleGenerator(
                         junctions,
                         elementsByGroup,
                         channel
-                    )
+                    ),
+                    rules?.AudienceAt(
+                        TimeOnly.FromDateTime(
+                            item.StartUtc.ToOffset(TimeSpan.FromMinutes(channel.UtcOffsetMinutes)).DateTime
+                        )
+                    ),
+                    repeatLimit
                 )
             );
         }

backend/src/TeleWave.Application/Programming/Planning/GroupExpander.cs

@@ -1,171 +1,232 @@
-using Microsoft.EntityFrameworkCore;
-using TeleWave.Application.Common.Interfaces;
-using TeleWave.Domain.Broadcast;
-using TeleWave.Domain.Media;
-using TeleWave.Domain.Programming;
-using TeleWave.Domain.Programming.Planning;
-
-namespace TeleWave.Application.Programming.Planning;
-
-/// <summary>
-/// Разворачивает группы в последовательности единиц воспроизведения для планировщика: сериал —
-/// в свои серии, коллекция — в части по порядку (сериал внутри коллекции тоже разворачивается),
-/// фильм — в одну единицу.
-///
-/// В эфир попадают только готовые ассеты с известной длительностью: поставить в ленту то, что ещё
-/// обрабатывается, значит получить дыру в раздаче.
-/// </summary>
-public sealed class GroupExpander(IAppDbContext dbContext)
-{
-    public async Task<IReadOnlyDictionary<Guid, IReadOnlyList<PlanningElement>>> ExpandAsync(
-        IReadOnlyCollection<Guid> groupIds,
-        Guid channelId,
-        CancellationToken cancellationToken
-    )
-    {
-        var result = new Dictionary<Guid, IReadOnlyList<PlanningElement>>();
-        if (groupIds.Count == 0)
-            return result;
-
-        var groups = await dbContext
-            .Groups.AsNoTracking()
-            .Include(g => g.Items)
-            .Where(g => groupIds.Contains(g.Id))
-            .ToListAsync(cancellationToken);
-
-        var collectionIds = groups
-            .SelectMany(g => g.Items)
-            .Where(i => i.ElementKind == GroupElementKind.Collection)
-            .Select(i => i.ElementId)
-            .Distinct()
-            .ToList();
-
-        var collectionParts = await dbContext
-            .CollectionItems.AsNoTracking()
-            .Where(i => collectionIds.Contains(i.CollectionId))
-            .OrderBy(i => i.Position)
-            .Select(i => new { i.CollectionId, i.ShowId })
-            .ToListAsync(cancellationToken);
-
-        var showIds = groups
-            .SelectMany(g => g.Items)
-            .Where(i => i.ElementKind == GroupElementKind.Show)
-            .Select(i => i.ElementId)
-            .Concat(collectionParts.Select(p => p.ShowId))
-            .Distinct()
-            .ToList();
-
-        var episodes = await dbContext
-            .Shows.AsNoTracking()
-            .Where(s => showIds.Contains(s.Id))
-            .Select(s => new
-            {
-                s.Id,
-                Episodes = s
-                    .Episodes.OrderBy(e => e.Position)
-                    .Select(e => new { e.MediaAssetId, e.Position })
-                    .ToList(),
-            })
-            .ToDictionaryAsync(s => s.Id, cancellationToken);
-
-        var assetIds = episodes.Values.SelectMany(s => s.Episodes.Select(e => e.MediaAssetId)).Distinct().ToList();
-        var durations = await dbContext
-            .MediaAssets.AsNoTracking()
-            .Where(a =>
-                assetIds.Contains(a.Id) && a.Status == MediaAssetStatus.Ready && a.Duration != null
-            )
-            .Select(a => new { a.Id, a.Duration })
-            .ToDictionaryAsync(a => a.Id, a => a.Duration!.Value, cancellationToken);
-
-        var lastPlayed = await LoadLastPlayedAsync(channelId, showIds, cancellationToken);
-
-        List<PlanningUnit> UnitsOfShow(Guid showId)
-        {
-            if (!episodes.TryGetValue(showId, out var show))
-                return [];
-
-            return show
-                .Episodes.Where(e => durations.ContainsKey(e.MediaAssetId))
-                .Select((e, index) => new PlanningUnit(
-                    e.MediaAssetId,
-                    durations[e.MediaAssetId],
-                    showId,
-                    index
-                ))
-                .ToList();
-        }
-
-        foreach (var group in groups)
-        {
-            var elements = new List<PlanningElement>();
-
-            foreach (var item in group.Items.OrderBy(i => i.Position))
-            {
-                if (item.ElementKind == GroupElementKind.Show)
-                {
-                    elements.Add(
-                        new PlanningElement(
-                            item.ElementKind,
-                            item.ElementId,
-                            item.Weight,
-                            item.Position,
-                            UnitsOfShow(item.ElementId),
-                            lastPlayed.TryGetValue(item.ElementId, out var played) ? played : null
-                        )
-                    );
-                    continue;
-                }
-
-                var partShowIds = collectionParts
-                    .Where(p => p.CollectionId == item.ElementId)
-                    .Select(p => p.ShowId)
-                    .ToList();
-
-                var units = partShowIds.SelectMany(UnitsOfShow).ToList();
-
-                elements.Add(
-                    new PlanningElement(
-                        item.ElementKind,
-                        item.ElementId,
-                        item.Weight,
-                        item.Position,
-                        units,
-                        // Остывание коллекции считается по самой свежей из её частей: показ любой
-                        // из них означает, что франшиза недавно была в эфире.
-                        partShowIds
-                            .Select(id => lastPlayed.TryGetValue(id, out var p) ? p : (DateTimeOffset?)null)
-                            .Where(p => p is not null)
-                            .DefaultIfEmpty(null)
-                            .Max()
-                    )
-                );
-            }
-
-            result[group.Id] = elements;
-        }
-
-        return result;
-    }
-
-    /// <summary>
-    /// Когда каждое шоу в последний раз выходило в этом канале. Источник — сама лента: отдельного
-    /// журнала показов нет, поэтому глубина хранения расписания должна покрывать максимальное
-    /// остывание среди правил.
-    /// </summary>
-    private async Task<Dictionary<Guid, DateTimeOffset>> LoadLastPlayedAsync(
-        Guid channelId,
-        IReadOnlyCollection<Guid> showIds,
-        CancellationToken cancellationToken
-    ) =>
-        await dbContext
-            .ScheduleEntries.AsNoTracking()
-            .Where(e =>
-                e.ChannelId == channelId
-                && e.Kind == ScheduleEntryKind.Program
-                && e.ShowId != null
-                && showIds.Contains(e.ShowId!.Value)
-            )
-            .GroupBy(e => e.ShowId!.Value)
-            .Select(g => new { ShowId = g.Key, LastPlayed = g.Max(e => e.StartsAtUtc) })
-            .ToDictionaryAsync(x => x.ShowId, x => x.LastPlayed, cancellationToken);
-}
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Domain.Broadcast;
+using TeleWave.Domain.Library;
+using TeleWave.Domain.Media;
+using TeleWave.Domain.Programming;
+using TeleWave.Domain.Programming.Planning;
+
+namespace TeleWave.Application.Programming.Planning;
+
+/// <summary>
+/// Разворачивает группы в последовательности единиц воспроизведения для планировщика: сериал —
+/// в свои серии, коллекция — в части по порядку (сериал внутри коллекции тоже разворачивается),
+/// фильм — в одну единицу.
+///
+/// В эфир попадают только готовые ассеты с известной длительностью: поставить в ленту то, что ещё
+/// обрабатывается, значит получить дыру в раздаче.
+/// </summary>
+public sealed class GroupExpander(IAppDbContext dbContext)
+{
+    /// <param name="historyFrom">С какого момента нужна история показов для потолка повторов;
+    /// null — история не нужна и не загружается.</param>
+    public async Task<IReadOnlyDictionary<Guid, IReadOnlyList<PlanningElement>>> ExpandAsync(
+        IReadOnlyCollection<Guid> groupIds,
+        Guid channelId,
+        CancellationToken cancellationToken,
+        DateTimeOffset? historyFrom = null
+    )
+    {
+        var result = new Dictionary<Guid, IReadOnlyList<PlanningElement>>();
+        if (groupIds.Count == 0)
+            return result;
+
+        var groups = await dbContext
+            .Groups.AsNoTracking()
+            .Include(g => g.Items)
+            .Where(g => groupIds.Contains(g.Id))
+            .ToListAsync(cancellationToken);
+
+        var collectionIds = groups
+            .SelectMany(g => g.Items)
+            .Where(i => i.ElementKind == GroupElementKind.Collection)
+            .Select(i => i.ElementId)
+            .Distinct()
+            .ToList();
+
+        var collectionParts = await dbContext
+            .CollectionItems.AsNoTracking()
+            .Where(i => collectionIds.Contains(i.CollectionId))
+            .OrderBy(i => i.Position)
+            .Select(i => new { i.CollectionId, i.ShowId })
+            .ToListAsync(cancellationToken);
+
+        var showIds = groups
+            .SelectMany(g => g.Items)
+            .Where(i => i.ElementKind == GroupElementKind.Show)
+            .Select(i => i.ElementId)
+            .Concat(collectionParts.Select(p => p.ShowId))
+            .Distinct()
+            .ToList();
+
+        var episodes = await dbContext
+            .Shows.AsNoTracking()
+            .Where(s => showIds.Contains(s.Id))
+            .Select(s => new
+            {
+                s.Id,
+                s.Audience,
+                Episodes = s
+                    .Episodes.OrderBy(e => e.Position)
+                    .Select(e => new { e.MediaAssetId, e.Position })
+                    .ToList(),
+            })
+            .ToDictionaryAsync(s => s.Id, cancellationToken);
+
+        var assetIds = episodes.Values.SelectMany(s => s.Episodes.Select(e => e.MediaAssetId)).Distinct().ToList();
+        var durations = await dbContext
+            .MediaAssets.AsNoTracking()
+            .Where(a =>
+                assetIds.Contains(a.Id) && a.Status == MediaAssetStatus.Ready && a.Duration != null
+            )
+            .Select(a => new { a.Id, a.Duration })
+            .ToDictionaryAsync(a => a.Id, a => a.Duration!.Value, cancellationToken);
+
+        var lastPlayed = await LoadLastPlayedAsync(channelId, showIds, cancellationToken);
+        var recentPlays = await LoadRecentPlaysAsync(
+            channelId,
+            showIds,
+            historyFrom,
+            cancellationToken
+        );
+
+        List<PlanningUnit> UnitsOfShow(Guid showId)
+        {
+            if (!episodes.TryGetValue(showId, out var show))
+                return [];
+
+            return show
+                .Episodes.Where(e => durations.ContainsKey(e.MediaAssetId))
+                .Select((e, index) => new PlanningUnit(
+                    e.MediaAssetId,
+                    durations[e.MediaAssetId],
+                    showId,
+                    index
+                ))
+                .ToList();
+        }
+
+        foreach (var group in groups)
+        {
+            var elements = new List<PlanningElement>();
+
+            foreach (var item in group.Items.OrderBy(i => i.Position))
+            {
+                if (item.ElementKind == GroupElementKind.Show)
+                {
+                    elements.Add(
+                        new PlanningElement(
+                            item.ElementKind,
+                            item.ElementId,
+                            item.Weight,
+                            item.Position,
+                            UnitsOfShow(item.ElementId),
+                            lastPlayed.TryGetValue(item.ElementId, out var played) ? played : null,
+                            episodes.TryGetValue(item.ElementId, out var show) ? show.Audience : null,
+                            recentPlays.TryGetValue(item.ElementId, out var plays) ? plays : null
+                        )
+                    );
+                    continue;
+                }
+
+                var partShowIds = collectionParts
+                    .Where(p => p.CollectionId == item.ElementId)
+                    .Select(p => p.ShowId)
+                    .ToList();
+
+                var units = partShowIds.SelectMany(UnitsOfShow).ToList();
+
+                elements.Add(
+                    new PlanningElement(
+                        item.ElementKind,
+                        item.ElementId,
+                        item.Weight,
+                        item.Position,
+                        units,
+                        // Остывание коллекции считается по самой свежей из её частей: показ любой
+                        // из них означает, что франшиза недавно была в эфире.
+                        partShowIds
+                            .Select(id => lastPlayed.TryGetValue(id, out var p) ? p : (DateTimeOffset?)null)
+                            .Where(p => p is not null)
+                            .DefaultIfEmpty(null)
+                            .Max(),
+                        // Категория коллекции — строжайшая среди частей: франшиза идёт целиком,
+                        // и одна взрослая часть делает взрослой всю.
+                        partShowIds
+                            .Select(id =>
+                                episodes.TryGetValue(id, out var part) ? part.Audience : (ShowAudience?)null
+                            )
+                            .Where(a => a is not null)
+                            .DefaultIfEmpty(null)
+                            .Max(),
+                        partShowIds
+                            .SelectMany(id =>
+                                recentPlays.TryGetValue(id, out var p) ? p : []
+                            )
+                            .ToList()
+                    )
+                );
+            }
+
+            result[group.Id] = elements;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Когда каждое шоу в последний раз выходило в этом канале. Источник — сама лента: отдельного
+    /// журнала показов нет, поэтому глубина хранения расписания должна покрывать максимальное
+    /// остывание среди правил.
+    /// </summary>
+    private async Task<Dictionary<Guid, DateTimeOffset>> LoadLastPlayedAsync(
+        Guid channelId,
+        IReadOnlyCollection<Guid> showIds,
+        CancellationToken cancellationToken
+    ) =>
+        await dbContext
+            .ScheduleEntries.AsNoTracking()
+            .Where(e =>
+                e.ChannelId == channelId
+                && e.Kind == ScheduleEntryKind.Program
+                && e.ShowId != null
+                && showIds.Contains(e.ShowId!.Value)
+            )
+            .GroupBy(e => e.ShowId!.Value)
+            .Select(g => new { ShowId = g.Key, LastPlayed = g.Max(e => e.StartsAtUtc) })
+            .ToDictionaryAsync(x => x.ShowId, x => x.LastPlayed, cancellationToken);
+
+    /// <summary>
+    /// Старты показов за окно потолка повторов. Загружается только когда правило задано: без него
+    /// это лишние сотни строк на каждый прогон.
+    /// </summary>
+    private async Task<Dictionary<Guid, IReadOnlyList<DateTimeOffset>>> LoadRecentPlaysAsync(
+        Guid channelId,
+        IReadOnlyCollection<Guid> showIds,
+        DateTimeOffset? from,
+        CancellationToken cancellationToken
+    )
+    {
+        if (from is not { } since || showIds.Count == 0)
+            return [];
+
+        var plays = await dbContext
+            .ScheduleEntries.AsNoTracking()
+            .Where(e =>
+                e.ChannelId == channelId
+                && e.Kind == ScheduleEntryKind.Program
+                && e.ShowId != null
+                && showIds.Contains(e.ShowId!.Value)
+                && e.StartsAtUtc >= since
+            )
+            .Select(e => new { ShowId = e.ShowId!.Value, e.StartsAtUtc })
+            .ToListAsync(cancellationToken);
+
+        return plays
+            .GroupBy(p => p.ShowId)
+            .ToDictionary(
+                g => g.Key,
+                g => (IReadOnlyList<DateTimeOffset>)g.Select(p => p.StartsAtUtc).ToList()
+            );
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/GetTemplate/GetChannelTemplateQueryHandler.cs

@@ -88,6 +88,7 @@ public sealed class GetChannelTemplateQueryHandler(IAppDbContext dbContext)
                 template.Name,
                 template.FallbackGroupId,
                 template.DefaultJunctionId,
+                PlanningRules.FromJson(template.RulesJson),
                 template.Revision,
                 template.AppliedRevision,
                 template.HasPendingChanges,

backend/src/TeleWave.Application/Programming/Templates/Layers/LayerCommandHandlers.cs

@@ -92,6 +92,7 @@ public sealed class UpdateTemplateCommandHandler(IAppDbContext dbContext)
         template.Rename(command.Name);
         template.SetFallbackGroup(command.FallbackGroupId);
         template.SetDefaultJunction(command.DefaultJunctionId);
+        template.SetRules(command.Rules?.ToJson());
         template.MarkChanged();
         return Result.Success();
     }

backend/src/TeleWave.Application/Programming/Templates/Layers/LayerCommands.cs

@@ -17,12 +17,13 @@ public sealed record UpdateLayerCommand(
 
 public sealed record DeleteLayerCommand(Guid LayerId) : ICommand<Result>;
 
-/// <summary>Имя шаблона и аварийная группа, играющая, когда пуст даже фоновый слой.</summary>
+/// <summary>Имя шаблона, аварийная группа, стык по умолчанию и правила отбора кандидатов.</summary>
 public sealed record UpdateTemplateCommand(
     Guid TemplateId,
     string Name,
     Guid? FallbackGroupId,
-    Guid? DefaultJunctionId
+    Guid? DefaultJunctionId,
+    PlanningRules? Rules
 ) : ICommand<Result>;
 
 public sealed class CreateLayerCommandValidator : AbstractValidator<CreateLayerCommand>
@@ -45,5 +46,22 @@ public sealed class UpdateLayerCommandValidator : AbstractValidator<UpdateLayerC
 
 public sealed class UpdateTemplateCommandValidator : AbstractValidator<UpdateTemplateCommand>
 {
-    public UpdateTemplateCommandValidator() => RuleFor(x => x.Name).NotEmpty().MaximumLength(256);
+    public UpdateTemplateCommandValidator()
+    {
+        RuleFor(x => x.Name).NotEmpty().MaximumLength(256);
+
+        // Год — верхняя граница окна повторов: за ним правило перестаёт что-либо значить, а история
+        // всё равно ограничена глубиной хранения ленты.
+        RuleFor(x => x.Rules!.MaxRepeatsInWindow!.WindowDays)
+            .InclusiveBetween(1, 365)
+            .When(x => x.Rules?.MaxRepeatsInWindow is not null);
+        RuleFor(x => x.Rules!.MaxRepeatsInWindow!.Max)
+            .InclusiveBetween(1, 1000)
+            .When(x => x.Rules?.MaxRepeatsInWindow is not null);
+
+        RuleForEach(x => x.Rules!.MaxAudienceByTime)
+            .Must(window => window.From != window.To)
+            .WithMessage("Окно нулевой длины ничего не ограничивает.")
+            .When(x => x.Rules?.MaxAudienceByTime is not null);
+    }
 }

backend/src/TeleWave.Application/Programming/Templates/PlanningRules.cs

@@ -0,0 +1,72 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using TeleWave.Domain.Library;
+
+namespace TeleWave.Application.Programming.Templates;
+
+/// <summary>
+/// Окно детского времени: с <paramref name="From"/> до <paramref name="To"/> во времени канала
+/// в эфир идёт только контент не строже <paramref name="MaxAudience"/>. Окно может переходить
+/// через полночь (23:00–06:00) — тогда границы сравниваются в обратную сторону.
+/// </summary>
+public sealed record AudienceWindow(TimeOnly From, TimeOnly To, ShowAudience MaxAudience)
+{
+    public bool Contains(TimeOnly moment) =>
+        From <= To ? moment >= From && moment < To : moment >= From || moment < To;
+}
+
+/// <summary>
+/// Правила отбора кандидатов на уровне канала (см. 3.8). Это жёсткие фильтры: они отсекают
+/// недопустимое до жребия, поэтому не требуют пересборки и не ломают воспроизводимость.
+///
+/// Область действия — весь канал: дейпарты сюда не заведены намеренно, окна детского времени
+/// и так задаются временем, а потолок повторов осмыслен только целиком по каналу.
+/// </summary>
+public sealed record PlanningRules(
+    IReadOnlyList<AudienceWindow>? MaxAudienceByTime = null,
+    /// <summary>Не чаще <c>Max</c> раз за <c>WindowDays</c> суток (null — без ограничения).</summary>
+    RepeatLimitRule? MaxRepeatsInWindow = null
+)
+{
+    private static readonly JsonSerializerOptions Options = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        Converters = { new JsonStringEnumConverter() },
+    };
+
+    /// <summary>Возрастной потолок в указанный момент времени канала (null — без ограничения).</summary>
+    public ShowAudience? AudienceAt(TimeOnly moment)
+    {
+        if (MaxAudienceByTime is not { Count: > 0 } windows)
+            return null;
+
+        // Пересекающиеся окна разрешаются в пользу строгого: детское время не должно
+        // отменяться более широким окном, случайно наложенным сверху.
+        ShowAudience? strictest = null;
+        foreach (var window in windows.Where(w => w.Contains(moment)))
+            strictest = strictest is { } current && current <= window.MaxAudience
+                ? current
+                : window.MaxAudience;
+        return strictest;
+    }
+
+    public string ToJson() => JsonSerializer.Serialize(this, Options);
+
+    public static PlanningRules? FromJson(string? json)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+            return null;
+
+        try
+        {
+            return JsonSerializer.Deserialize<PlanningRules>(json, Options);
+        }
+        catch (JsonException)
+        {
+            return null;
+        }
+    }
+}
+
+public sealed record RepeatLimitRule(int WindowDays, int Max);

backend/src/TeleWave.Application/Programming/Templates/TemplateDtos.cs

@@ -41,6 +41,8 @@ public sealed record ScheduleTemplateDto(
     string Name,
     Guid? FallbackGroupId,
     Guid? DefaultJunctionId,
+    /// <summary>Правила отбора кандидатов канала: детское время и потолок повторов.</summary>
+    PlanningRules? Rules,
     int Revision,
     int AppliedRevision,
     /// <summary>Есть ли правки правил, ещё не применённые к эфиру.</summary>