Refactor .gitignore to streamline ignored files and enhance clarity. Update CLAUDE.md to improve unit test instructions and add coverage reporting details. Revise README.md for better project overview and deployment instructions. Refactor ChannelEndpoints and StreamingEndpoints to utilize SegmentFiles for file resolution, improving code maintainability. Remove unused JunctionHandlers and update DependencyInjection for cleaner service registration. Enhance media processing services for better job handling and error management. Update frontend API types for consistency and clarity.

backend/src/TeleWave.Application/Programming/Groups/GroupErrors.cs

@@ -16,11 +16,6 @@ public static class GroupErrors
         "Шоу или коллекция не найдены."
     );
 
-    public static readonly Error ElementAlreadyAdded = Error.Conflict(
-        "Groups.ElementAlreadyAdded",
-        "Этот элемент уже входит в группу."
-    );
-
     public static readonly Error FilterNotSet = Error.Validation(
         "Groups.FilterNotSet",
         "У группы не задано правило набора."

backend/src/TeleWave.Application/Programming/Templates/Junctions/AddJunctionElementCommandHandler.cs

@@ -0,0 +1,27 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class AddJunctionElementCommandHandler(IAppDbContext dbContext)
+    : ICommandHandler<AddJunctionElementCommand, Result<Guid>>
+{
+    public async Task<Result<Guid>> Handle(
+        AddJunctionElementCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        var junction = await JunctionLoader.LoadAsync(
+            dbContext,
+            command.JunctionId,
+            cancellationToken
+        );
+        if (junction is null)
+            return Result.Failure<Guid>(TemplateErrors.JunctionNotFound);
+
+        var element = junction.AddElement(command.Kind);
+        await JunctionLoader.MarkTemplateChangedAsync(dbContext, junction, cancellationToken);
+        return Result.Success(element.Id);
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/CreateJunctionCommandHandler.cs

@@ -0,0 +1,25 @@
+using LiteCqrs;
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Broadcast;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+using TeleWave.Domain.Programming;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class CreateJunctionCommandHandler(IAppDbContext dbContext)
+    : ICommandHandler<CreateJunctionCommand, Result<Guid>>
+{
+    public async Task<Result<Guid>> Handle(
+        CreateJunctionCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        if (!await dbContext.Channels.AnyAsync(c => c.Id == command.ChannelId, cancellationToken))
+            return Result.Failure<Guid>(ChannelErrors.NotFound);
+
+        var junction = JunctionTemplate.Create(command.ChannelId, command.Name);
+        dbContext.JunctionTemplates.Add(junction);
+        return Result.Success(junction.Id);
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/DeleteJunctionCommandHandler.cs

@@ -0,0 +1,39 @@
+using LiteCqrs;
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class DeleteJunctionCommandHandler(IAppDbContext dbContext)
+    : ICommandHandler<DeleteJunctionCommand, Result>
+{
+    public async Task<Result> Handle(
+        DeleteJunctionCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        var junction = await JunctionLoader.LoadAsync(
+            dbContext,
+            command.JunctionId,
+            cancellationToken
+        );
+        if (junction is null)
+            return Result.Failure(TemplateErrors.JunctionNotFound);
+
+        // Слот, ссылающийся на удалённый стык, молча остался бы без врезок — проверяем заранее.
+        var used = await dbContext.Slots.AnyAsync(
+            s => s.JunctionBetweenId == junction.Id || s.JunctionAfterId == junction.Id,
+            cancellationToken
+        );
+        if (used)
+            return Result.Failure(TemplateErrors.JunctionInUse);
+
+        dbContext.JunctionTemplates.Remove(junction);
+        return await JunctionLoader.MarkTemplateChangedAsync(
+            dbContext,
+            junction,
+            cancellationToken
+        );
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/JunctionHandlers.cs

@@ -1,297 +0,0 @@
-using LiteCqrs;
-using Microsoft.EntityFrameworkCore;
-using TeleWave.Application.Broadcast;
-using TeleWave.Application.Common.Interfaces;
-using TeleWave.Application.Common.Models;
-using TeleWave.Domain.Programming;
-
-namespace TeleWave.Application.Programming.Templates.Junctions;
-
-public sealed class ListJunctionsQueryHandler(IAppDbContext dbContext)
-    : IQueryHandler<ListJunctionsQuery, IReadOnlyList<JunctionTemplateDto>>
-{
-    public async Task<IReadOnlyList<JunctionTemplateDto>> Handle(
-        ListJunctionsQuery query,
-        CancellationToken cancellationToken
-    )
-    {
-        var junctions = await dbContext
-            .JunctionTemplates.AsNoTracking()
-            .Include(j => j.Elements)
-            .Where(j => j.ChannelId == query.ChannelId)
-            .OrderBy(j => j.Name)
-            .ToListAsync(cancellationToken);
-
-        // Имена групп и блоков заставок резолвим одним проходом — редактор показывает их сразу.
-        var groupIds = junctions
-            .SelectMany(j => j.Elements)
-            .Select(e => e.GroupId)
-            .Where(id => id is not null)
-            .Select(id => id!.Value)
-            .Distinct()
-            .ToList();
-        var groupNames = await dbContext
-            .Groups.AsNoTracking()
-            .Where(g => groupIds.Contains(g.Id))
-            .ToDictionaryAsync(g => g.Id, g => g.Name, cancellationToken);
-
-        var bumperNames = await dbContext
-            .Channels.AsNoTracking()
-            .Where(c => c.Id == query.ChannelId)
-            .SelectMany(c => c.BumperTemplates)
-            .ToDictionaryAsync(t => t.Id, t => t.Name, cancellationToken);
-
-        return junctions
-            .Select(j => new JunctionTemplateDto(
-                j.Id,
-                j.Name,
-                j.Elements.OrderBy(e => e.Position)
-                    .Select(e => new JunctionElementDto(
-                        e.Id,
-                        e.Position,
-                        e.Kind,
-                        e.GroupId,
-                        e.GroupId is { } gid && groupNames.TryGetValue(gid, out var gname)
-                            ? gname
-                            : null,
-                        e.BumperTemplateId,
-                        e.BumperTemplateId is { } bid && bumperNames.TryGetValue(bid, out var bname)
-                            ? bname
-                            : null,
-                        e.AmountMode,
-                        e.AmountValue,
-                        e.IsRequired,
-                        JunctionConditions.FromJson(e.ConditionsJson)
-                    ))
-                    .ToList()
-            ))
-            .ToList();
-    }
-}
-
-public sealed class CreateJunctionCommandHandler(IAppDbContext dbContext)
-    : ICommandHandler<CreateJunctionCommand, Result<Guid>>
-{
-    public async Task<Result<Guid>> Handle(
-        CreateJunctionCommand command,
-        CancellationToken cancellationToken
-    )
-    {
-        if (!await dbContext.Channels.AnyAsync(c => c.Id == command.ChannelId, cancellationToken))
-            return Result.Failure<Guid>(ChannelErrors.NotFound);
-
-        var junction = JunctionTemplate.Create(command.ChannelId, command.Name);
-        dbContext.JunctionTemplates.Add(junction);
-        return Result.Success(junction.Id);
-    }
-}
-
-public sealed class RenameJunctionCommandHandler(IAppDbContext dbContext)
-    : ICommandHandler<RenameJunctionCommand, Result>
-{
-    public async Task<Result> Handle(
-        RenameJunctionCommand command,
-        CancellationToken cancellationToken
-    )
-    {
-        var junction = await JunctionLoader.LoadAsync(
-            dbContext,
-            command.JunctionId,
-            cancellationToken
-        );
-        if (junction is null)
-            return Result.Failure(TemplateErrors.JunctionNotFound);
-
-        junction.Rename(command.Name);
-        return await MarkTemplateChangedAsync(dbContext, junction, cancellationToken);
-    }
-
-    /// <summary>Правка стыка — тоже правка правил эфира: шаблон канала помечается изменённым.</summary>
-    internal static async Task<Result> MarkTemplateChangedAsync(
-        IAppDbContext dbContext,
-        JunctionTemplate junction,
-        CancellationToken cancellationToken
-    )
-    {
-        var template = await dbContext.ScheduleTemplates.FirstOrDefaultAsync(
-            t => t.ChannelId == junction.ChannelId,
-            cancellationToken
-        );
-        template?.MarkChanged();
-        return Result.Success();
-    }
-}
-
-public sealed class DeleteJunctionCommandHandler(IAppDbContext dbContext)
-    : ICommandHandler<DeleteJunctionCommand, Result>
-{
-    public async Task<Result> Handle(
-        DeleteJunctionCommand command,
-        CancellationToken cancellationToken
-    )
-    {
-        var junction = await JunctionLoader.LoadAsync(
-            dbContext,
-            command.JunctionId,
-            cancellationToken
-        );
-        if (junction is null)
-            return Result.Failure(TemplateErrors.JunctionNotFound);
-
-        // Слот, ссылающийся на удалённый стык, молча остался бы без врезок — проверяем заранее.
-        var used = await dbContext.Slots.AnyAsync(
-            s => s.JunctionBetweenId == junction.Id || s.JunctionAfterId == junction.Id,
-            cancellationToken
-        );
-        if (used)
-            return Result.Failure(TemplateErrors.JunctionInUse);
-
-        dbContext.JunctionTemplates.Remove(junction);
-        return await RenameJunctionCommandHandler.MarkTemplateChangedAsync(
-            dbContext,
-            junction,
-            cancellationToken
-        );
-    }
-}
-
-public sealed class AddJunctionElementCommandHandler(IAppDbContext dbContext)
-    : ICommandHandler<AddJunctionElementCommand, Result<Guid>>
-{
-    public async Task<Result<Guid>> Handle(
-        AddJunctionElementCommand command,
-        CancellationToken cancellationToken
-    )
-    {
-        var junction = await JunctionLoader.LoadAsync(
-            dbContext,
-            command.JunctionId,
-            cancellationToken
-        );
-        if (junction is null)
-            return Result.Failure<Guid>(TemplateErrors.JunctionNotFound);
-
-        var element = junction.AddElement(command.Kind);
-        await RenameJunctionCommandHandler.MarkTemplateChangedAsync(
-            dbContext,
-            junction,
-            cancellationToken
-        );
-        return Result.Success(element.Id);
-    }
-}
-
-public sealed class UpdateJunctionElementCommandHandler(IAppDbContext dbContext)
-    : ICommandHandler<UpdateJunctionElementCommand, Result>
-{
-    public async Task<Result> Handle(
-        UpdateJunctionElementCommand command,
-        CancellationToken cancellationToken
-    )
-    {
-        var junction = await JunctionLoader.LoadAsync(
-            dbContext,
-            command.JunctionId,
-            cancellationToken
-        );
-        var element = junction?.FindElement(command.ElementId);
-        if (junction is null || element is null)
-            return Result.Failure(TemplateErrors.JunctionElementNotFound);
-
-        var input = command.Input;
-
-        if (input.Kind == JunctionElementKind.Bumper)
-        {
-            var known = await dbContext
-                .Channels.Where(c => c.Id == junction.ChannelId)
-                .SelectMany(c => c.BumperTemplates)
-                .AnyAsync(t => t.Id == input.BumperTemplateId, cancellationToken);
-            if (!known)
-                return Result.Failure(ChannelErrors.BumperTemplateNotFound);
-        }
-        else
-        {
-            if (input.GroupId is not { } groupId)
-                return Result.Failure(TemplateErrors.JunctionGroupRequired);
-            if (!await dbContext.Groups.AnyAsync(g => g.Id == groupId, cancellationToken))
-                return Result.Failure(TemplateErrors.GroupNotFound);
-        }
-
-        element.Update(
-            input.Kind,
-            input.GroupId,
-            input.BumperTemplateId,
-            input.AmountMode,
-            input.AmountValue,
-            input.IsRequired,
-            input.Conditions?.ToJson()
-        );
-
-        return await RenameJunctionCommandHandler.MarkTemplateChangedAsync(
-            dbContext,
-            junction,
-            cancellationToken
-        );
-    }
-}
-
-public sealed class RemoveJunctionElementCommandHandler(IAppDbContext dbContext)
-    : ICommandHandler<RemoveJunctionElementCommand, Result>
-{
-    public async Task<Result> Handle(
-        RemoveJunctionElementCommand command,
-        CancellationToken cancellationToken
-    )
-    {
-        var junction = await JunctionLoader.LoadAsync(
-            dbContext,
-            command.JunctionId,
-            cancellationToken
-        );
-        if (junction is null || !junction.RemoveElement(command.ElementId))
-            return Result.Failure(TemplateErrors.JunctionElementNotFound);
-
-        return await RenameJunctionCommandHandler.MarkTemplateChangedAsync(
-            dbContext,
-            junction,
-            cancellationToken
-        );
-    }
-}
-
-public sealed class ReorderJunctionCommandHandler(IAppDbContext dbContext)
-    : ICommandHandler<ReorderJunctionCommand, Result>
-{
-    public async Task<Result> Handle(
-        ReorderJunctionCommand command,
-        CancellationToken cancellationToken
-    )
-    {
-        var junction = await JunctionLoader.LoadAsync(
-            dbContext,
-            command.JunctionId,
-            cancellationToken
-        );
-        if (junction is null)
-            return Result.Failure(TemplateErrors.JunctionNotFound);
-
-        junction.Reorder(command.ElementIdsInOrder);
-        return await RenameJunctionCommandHandler.MarkTemplateChangedAsync(
-            dbContext,
-            junction,
-            cancellationToken
-        );
-    }
-}
-
-internal static class JunctionLoader
-{
-    public static Task<JunctionTemplate?> LoadAsync(
-        IAppDbContext dbContext,
-        Guid junctionId,
-        CancellationToken cancellationToken
-    ) =>
-        dbContext
-            .JunctionTemplates.Include(j => j.Elements)
-            .FirstOrDefaultAsync(j => j.Id == junctionId, cancellationToken);
-}

backend/src/TeleWave.Application/Programming/Templates/Junctions/JunctionLoader.cs

@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+using TeleWave.Domain.Programming;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+/// <summary>Общее для всех команд стыка: загрузка шаблона и отметка правил эфира изменёнными.</summary>
+internal static class JunctionLoader
+{
+    public static Task<JunctionTemplate?> LoadAsync(
+        IAppDbContext dbContext,
+        Guid junctionId,
+        CancellationToken cancellationToken
+    ) =>
+        dbContext
+            .JunctionTemplates.Include(j => j.Elements)
+            .FirstOrDefaultAsync(j => j.Id == junctionId, cancellationToken);
+
+    /// <summary>Правка стыка — тоже правка правил эфира: шаблон канала помечается изменённым.</summary>
+    public static async Task<Result> MarkTemplateChangedAsync(
+        IAppDbContext dbContext,
+        JunctionTemplate junction,
+        CancellationToken cancellationToken
+    )
+    {
+        var template = await dbContext.ScheduleTemplates.FirstOrDefaultAsync(
+            t => t.ChannelId == junction.ChannelId,
+            cancellationToken
+        );
+        template?.MarkChanged();
+        return Result.Success();
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/ListJunctionsQueryHandler.cs

@@ -0,0 +1,67 @@
+using LiteCqrs;
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Common.Interfaces;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class ListJunctionsQueryHandler(IAppDbContext dbContext)
+    : IQueryHandler<ListJunctionsQuery, IReadOnlyList<JunctionTemplateDto>>
+{
+    public async Task<IReadOnlyList<JunctionTemplateDto>> Handle(
+        ListJunctionsQuery query,
+        CancellationToken cancellationToken
+    )
+    {
+        var junctions = await dbContext
+            .JunctionTemplates.AsNoTracking()
+            .Include(j => j.Elements)
+            .Where(j => j.ChannelId == query.ChannelId)
+            .OrderBy(j => j.Name)
+            .ToListAsync(cancellationToken);
+
+        // Имена групп и блоков заставок резолвим одним проходом — редактор показывает их сразу.
+        var groupIds = junctions
+            .SelectMany(j => j.Elements)
+            .Select(e => e.GroupId)
+            .Where(id => id is not null)
+            .Select(id => id!.Value)
+            .Distinct()
+            .ToList();
+        var groupNames = await dbContext
+            .Groups.AsNoTracking()
+            .Where(g => groupIds.Contains(g.Id))
+            .ToDictionaryAsync(g => g.Id, g => g.Name, cancellationToken);
+
+        var bumperNames = await dbContext
+            .Channels.AsNoTracking()
+            .Where(c => c.Id == query.ChannelId)
+            .SelectMany(c => c.BumperTemplates)
+            .ToDictionaryAsync(t => t.Id, t => t.Name, cancellationToken);
+
+        return junctions
+            .Select(j => new JunctionTemplateDto(
+                j.Id,
+                j.Name,
+                j.Elements.OrderBy(e => e.Position)
+                    .Select(e => new JunctionElementDto(
+                        e.Id,
+                        e.Position,
+                        e.Kind,
+                        e.GroupId,
+                        e.GroupId is { } gid && groupNames.TryGetValue(gid, out var gname)
+                            ? gname
+                            : null,
+                        e.BumperTemplateId,
+                        e.BumperTemplateId is { } bid && bumperNames.TryGetValue(bid, out var bname)
+                            ? bname
+                            : null,
+                        e.AmountMode,
+                        e.AmountValue,
+                        e.IsRequired,
+                        JunctionConditions.FromJson(e.ConditionsJson)
+                    ))
+                    .ToList()
+            ))
+            .ToList();
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/RemoveJunctionElementCommandHandler.cs

@@ -0,0 +1,29 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class RemoveJunctionElementCommandHandler(IAppDbContext dbContext)
+    : ICommandHandler<RemoveJunctionElementCommand, Result>
+{
+    public async Task<Result> Handle(
+        RemoveJunctionElementCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        var junction = await JunctionLoader.LoadAsync(
+            dbContext,
+            command.JunctionId,
+            cancellationToken
+        );
+        if (junction is null || !junction.RemoveElement(command.ElementId))
+            return Result.Failure(TemplateErrors.JunctionElementNotFound);
+
+        return await JunctionLoader.MarkTemplateChangedAsync(
+            dbContext,
+            junction,
+            cancellationToken
+        );
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/RenameJunctionCommandHandler.cs

@@ -0,0 +1,30 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class RenameJunctionCommandHandler(IAppDbContext dbContext)
+    : ICommandHandler<RenameJunctionCommand, Result>
+{
+    public async Task<Result> Handle(
+        RenameJunctionCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        var junction = await JunctionLoader.LoadAsync(
+            dbContext,
+            command.JunctionId,
+            cancellationToken
+        );
+        if (junction is null)
+            return Result.Failure(TemplateErrors.JunctionNotFound);
+
+        junction.Rename(command.Name);
+        return await JunctionLoader.MarkTemplateChangedAsync(
+            dbContext,
+            junction,
+            cancellationToken
+        );
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/ReorderJunctionCommandHandler.cs

@@ -0,0 +1,30 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class ReorderJunctionCommandHandler(IAppDbContext dbContext)
+    : ICommandHandler<ReorderJunctionCommand, Result>
+{
+    public async Task<Result> Handle(
+        ReorderJunctionCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        var junction = await JunctionLoader.LoadAsync(
+            dbContext,
+            command.JunctionId,
+            cancellationToken
+        );
+        if (junction is null)
+            return Result.Failure(TemplateErrors.JunctionNotFound);
+
+        junction.Reorder(command.ElementIdsInOrder);
+        return await JunctionLoader.MarkTemplateChangedAsync(
+            dbContext,
+            junction,
+            cancellationToken
+        );
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Junctions/UpdateJunctionElementCommandHandler.cs

@@ -0,0 +1,62 @@
+using LiteCqrs;
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Broadcast;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+using TeleWave.Domain.Programming;
+
+namespace TeleWave.Application.Programming.Templates.Junctions;
+
+public sealed class UpdateJunctionElementCommandHandler(IAppDbContext dbContext)
+    : ICommandHandler<UpdateJunctionElementCommand, Result>
+{
+    public async Task<Result> Handle(
+        UpdateJunctionElementCommand command,
+        CancellationToken cancellationToken
+    )
+    {
+        var junction = await JunctionLoader.LoadAsync(
+            dbContext,
+            command.JunctionId,
+            cancellationToken
+        );
+        var element = junction?.FindElement(command.ElementId);
+        if (junction is null || element is null)
+            return Result.Failure(TemplateErrors.JunctionElementNotFound);
+
+        var input = command.Input;
+
+        if (input.Kind == JunctionElementKind.Bumper)
+        {
+            var known = await dbContext
+                .Channels.Where(c => c.Id == junction.ChannelId)
+                .SelectMany(c => c.BumperTemplates)
+                .AnyAsync(t => t.Id == input.BumperTemplateId, cancellationToken);
+            if (!known)
+                return Result.Failure(ChannelErrors.BumperTemplateNotFound);
+        }
+        else
+        {
+            if (input.GroupId is not { } groupId)
+                return Result.Failure(TemplateErrors.JunctionGroupRequired);
+            if (!await dbContext.Groups.AnyAsync(g => g.Id == groupId, cancellationToken))
+                return Result.Failure(TemplateErrors.GroupNotFound);
+        }
+
+        element.Update(
+            input.Kind,
+            input.GroupId,
+            input.BumperTemplateId,
+            input.AmountMode,
+            input.AmountValue,
+            input.IsRequired,
+            input.Conditions?.ToJson()
+        );
+
+        return await JunctionLoader.MarkTemplateChangedAsync(
+            dbContext,
+            junction,
+            cancellationToken
+        );
+    }
+}

backend/src/TeleWave.Application/Programming/Templates/Validate/ValidateTemplateQueryHandler.cs

@@ -281,9 +281,13 @@ public sealed class ValidateTemplateQueryHandler(IAppDbContext dbContext)
             .Select(i => new { i.CollectionId, i.ShowId })
             .ToListAsync(cancellationToken);
 
+        // Список id собираем до запроса: проекция по материализованной коллекции внутри дерева
+        // выражений заставляет EF пересобирать её на каждый вызов.
+        var neededShowIds = showIds.Concat(partsByCollection.Select(p => p.ShowId)).Distinct().ToList();
+
         var audiences = await dbContext
             .Shows.AsNoTracking()
-            .Where(s => showIds.Contains(s.Id) || partsByCollection.Select(p => p.ShowId).Contains(s.Id))
+            .Where(s => neededShowIds.Contains(s.Id))
             .Select(s => new { s.Id, s.Audience })
             .ToDictionaryAsync(s => s.Id, s => s.Audience, cancellationToken);