Add missing seasons endpoint and update metadata handling

Implemented a new endpoint to retrieve missing seasons for shows, enhancing the MetadataEndpoints class. Updated the IMetadataProvider interface to include a method for fetching season numbers. Adjusted the ShowSummaryDto to include other genres and modified the ListShowsQueryHandler to handle multiple genres. Enhanced the Omdb and Tmdb metadata providers to support season number retrieval. Updated frontend components to integrate missing seasons functionality, including API calls and UI elements for displaying missing seasons reports.

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

@@ -4,6 +4,7 @@ using TeleWave.Application.Metadata;
 using TeleWave.Application.Metadata.ApplyShowMetadata;
 using TeleWave.Application.Metadata.ClearShowMetadata;
 using TeleWave.Application.Metadata.FindMissingEpisodes;
+using TeleWave.Application.Metadata.FindMissingSeasons;
 using TeleWave.Application.Metadata.GetProviders;
 using TeleWave.Application.Metadata.RefreshEpisodes;
 using TeleWave.Application.Metadata.SearchShows;
@@ -34,6 +35,9 @@ public static class MetadataEndpoints
         admin
             .MapGet("/shows/{showId:guid}/missing-episodes", FindMissing)
             .Produces<MissingEpisodesReport>();
+        admin
+            .MapGet("/shows/{showId:guid}/missing-seasons", FindMissingSeasons)
+            .Produces<MissingSeasonsReport>();
 
         // Постеры шоу и кадры серий теперь в общем реестре и отдаются по /api/images/{id}.
         return app;
@@ -137,6 +141,16 @@ public static class MetadataEndpoints
         var result = await sender.Send(new FindMissingEpisodesQuery(showId), cancellationToken);
         return result.ToHttpResult();
     }
+
+    private static async Task<IResult> FindMissingSeasons(
+        Guid showId,
+        ISender sender,
+        CancellationToken cancellationToken
+    )
+    {
+        var result = await sender.Send(new FindMissingSeasonsQuery(showId), cancellationToken);
+        return result.ToHttpResult();
+    }
 }
 
 public sealed record ApplyMetadataBody(string Provider, string ExternalId);

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

@@ -48,6 +48,15 @@ public interface IMetadataProvider
         int season,
         CancellationToken cancellationToken
     );
+
+    /// <summary>
+    /// Номера сезонов сериала по данным источника (пусто — источник не отдал данные). Спецвыпуски
+    /// (нулевой сезон) не отдаются: в библиотеку они не грузятся и считались бы вечно отсутствующими.
+    /// </summary>
+    Task<IReadOnlyList<int>> GetSeasonNumbersAsync(
+        string externalId,
+        CancellationToken cancellationToken
+    );
 }
 
 /// <summary>Резолвит провайдер по ключу и перечисляет реально настроенные (с API-ключом) источники.</summary>

backend/src/TeleWave.Application/Library/ListShows/ListShowsQueryHandler.cs

@@ -32,16 +32,11 @@ public sealed class ListShowsQueryHandler(IAppDbContext dbContext)
 
         var shows = await filtered.OrderBy(s => s.Name).ToListAsync(cancellationToken);
 
-        // Названия только для основных жанров — в списке показывается один.
-        var primaryIds = shows
-            .Select(s => s.PrimaryGenreId)
-            .Where(id => id is not null)
-            .Select(id => id!.Value)
-            .Distinct()
-            .ToList();
+        // Названия всех проставленных жанров: основной показывается в колонке, прочие — под «…».
+        var genreIds = shows.SelectMany(s => s.Genres.Select(g => g.GenreId)).Distinct().ToList();
         var genreNames = await dbContext
             .Genres.AsNoTracking()
-            .Where(g => primaryIds.Contains(g.Id))
+            .Where(g => genreIds.Contains(g.Id))
             .ToDictionaryAsync(g => g.Id, g => g.Name, cancellationToken);
 
         // Имена ассетов нужны, чтобы распознать сезоны (номера в модели не хранятся).
@@ -81,7 +76,14 @@ public sealed class ListShowsQueryHandler(IAppDbContext dbContext)
                     s.PrimaryGenreId is { } primaryId
                     && genreNames.TryGetValue(primaryId, out var g)
                         ? g
-                        : null
+                        : null,
+                    [
+                        .. s
+                            .Genres.Where(x => !x.IsPrimary)
+                            .Select(x => genreNames.GetValueOrDefault(x.GenreId))
+                            .OfType<string>()
+                            .Order(StringComparer.OrdinalIgnoreCase),
+                    ]
                 );
             })
             .ToList();

backend/src/TeleWave.Application/Library/ShowDtos.cs

@@ -15,8 +15,10 @@ public sealed record ShowSummaryDto(
     int? Year,
     bool HasPoster,
     DateTimeOffset CreatedAt,
-    /// <summary>Название основного жанра — в списке показываем только его, остальные видны в карточке шоу.</summary>
-    string? PrimaryGenre = null
+    /// <summary>Название основного жанра — в списке колонка показывает его.</summary>
+    string? PrimaryGenre,
+    /// <summary>Названия прочих жанров — в списке прячутся под «…», полный набор правится в карточке шоу.</summary>
+    IReadOnlyList<string> OtherGenres
 );
 
 /// <summary>Жанр, проставленный шоу.</summary>

backend/src/TeleWave.Application/Metadata/FindMissingEpisodes/FindMissingEpisodesQueryHandler.cs

@@ -44,7 +44,7 @@ public sealed class FindMissingEpisodesQueryHandler(
             .Select(a => new { a.Id, a.OriginalFileName })
             .ToDictionaryAsync(a => a.Id, a => a.OriginalFileName, cancellationToken);
 
-        var loadedBySeason = GroupLoadedBySeason(show, names);
+        var loadedBySeason = LoadedEpisodeNumbers.GroupBySeason(show, names);
 
         var seasons = new List<SeasonGapDto>();
         foreach (var season in loadedBySeason.Keys.OrderBy(s => s))
@@ -63,41 +63,4 @@ public sealed class FindMissingEpisodesQueryHandler(
 
         return Result.Success(new MissingEpisodesReport(seasons));
     }
-
-    /// <summary>
-    /// Загруженные номера серий по сезонам — только те сезоны, где есть хотя бы одна серия. Номера
-    /// берутся проставленные, а при их отсутствии распознаются из имени файла (здесь, в отличие от
-    /// обновления метаданных, распознанное не сохраняется: запрос ничего не меняет).
-    /// </summary>
-    private static Dictionary<int, HashSet<int>> GroupLoadedBySeason(
-        Show show,
-        IReadOnlyDictionary<Guid, string> assetNames
-    )
-    {
-        var loadedBySeason = new Dictionary<int, HashSet<int>>();
-        foreach (var episode in show.Episodes)
-        {
-            if (ResolveNumbers(episode, assetNames) is not { } numbers)
-                continue;
-
-            if (!loadedBySeason.TryGetValue(numbers.Season, out var set))
-                loadedBySeason[numbers.Season] = set = [];
-            set.Add(numbers.Episode);
-        }
-        return loadedBySeason;
-    }
-
-    /// <summary>Сезон и номер серии: проставленные либо распознанные из имени файла; null — не вышло.</summary>
-    private static (int Season, int Episode)? ResolveNumbers(
-        ShowEpisode episode,
-        IReadOnlyDictionary<Guid, string> assetNames
-    )
-    {
-        if (episode.Season is { } season && episode.Episode is { } number)
-            return (season, number);
-
-        return assetNames.TryGetValue(episode.MediaAssetId, out var name)
-            ? EpisodeName.Parse(name)
-            : null;
-    }
 }

backend/src/TeleWave.Application/Metadata/FindMissingSeasons/FindMissingSeasonsQuery.cs

@@ -0,0 +1,21 @@
+using LiteCqrs;
+using TeleWave.Application.Common.Models;
+
+namespace TeleWave.Application.Metadata.FindMissingSeasons;
+
+/// <summary>Отчёт: каких сезонов шоу нет в библиотеке вовсе (по данным привязанного источника).</summary>
+public sealed record FindMissingSeasonsQuery(Guid ShowId) : IQuery<Result<MissingSeasonsReport>>;
+
+/// <param name="Expected">Сколько сезонов у сериала по источнику (null — источник не отдал данные).</param>
+/// <param name="Loaded">Номера сезонов, где загружена хотя бы одна серия.</param>
+/// <param name="Missing">Номера сезонов из источника, где не загружено ни одной серии.</param>
+/// <param name="Unknown">
+/// Загруженные сезоны, которых источник не знает (опечатка в номере либо чужая привязка) — пусто,
+/// если <paramref name="Expected"/> неизвестен.
+/// </param>
+public sealed record MissingSeasonsReport(
+    int? Expected,
+    IReadOnlyList<int> Loaded,
+    IReadOnlyList<int> Missing,
+    IReadOnlyList<int> Unknown
+);

backend/src/TeleWave.Application/Metadata/FindMissingSeasons/FindMissingSeasonsQueryHandler.cs

@@ -0,0 +1,63 @@
+using LiteCqrs;
+using Microsoft.EntityFrameworkCore;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Common.Models;
+using TeleWave.Application.Library;
+using TeleWave.Domain.Library;
+
+namespace TeleWave.Application.Metadata.FindMissingSeasons;
+
+public sealed class FindMissingSeasonsQueryHandler(
+    IAppDbContext dbContext,
+    IMetadataProviderResolver resolver
+) : IQueryHandler<FindMissingSeasonsQuery, Result<MissingSeasonsReport>>
+{
+    public async Task<Result<MissingSeasonsReport>> Handle(
+        FindMissingSeasonsQuery query,
+        CancellationToken cancellationToken
+    )
+    {
+        var show = await dbContext
+            .Shows.AsNoTracking()
+            .Include(s => s.Episodes)
+            .FirstOrDefaultAsync(s => s.Id == query.ShowId, cancellationToken);
+        if (show is null)
+            return Result.Failure<MissingSeasonsReport>(ShowErrors.NotFound);
+
+        // Сезоны есть только у сериала — см. FindMissingEpisodesQueryHandler.
+        if (show.Kind != ShowKind.Series)
+            return Result.Failure<MissingSeasonsReport>(MetadataErrors.EpisodesForSeriesOnly);
+
+        if (string.IsNullOrEmpty(show.MetadataExternalId))
+            return Result.Failure<MissingSeasonsReport>(MetadataErrors.NoLinkedSource);
+
+        var provider = show.MetadataProvider is { } key ? resolver.Resolve(key) : null;
+        if (provider is null)
+            return Result.Failure<MissingSeasonsReport>(MetadataErrors.ProviderNotAvailable);
+
+        // Имена файлов — чтобы распознать сезон у серий, где номера ещё не проставлены.
+        var assetIds = show.Episodes.Select(e => e.MediaAssetId).Distinct().ToList();
+        var names = await dbContext
+            .MediaAssets.AsNoTracking()
+            .Where(a => assetIds.Contains(a.Id))
+            .Select(a => new { a.Id, a.OriginalFileName })
+            .ToDictionaryAsync(a => a.Id, a => a.OriginalFileName, cancellationToken);
+
+        var loaded = LoadedEpisodeNumbers.GroupBySeason(show, names).Keys.ToHashSet();
+        var known = await provider.GetSeasonNumbersAsync(
+            show.MetadataExternalId,
+            cancellationToken
+        );
+
+        // Источник молчит — отдаём только загруженное: считать все сезоны отсутствующими или,
+        // наоборот, лишними было бы одинаково неверно.
+        return Result.Success(
+            new MissingSeasonsReport(
+                known.Count > 0 ? known.Count : null,
+                [.. loaded.Order()],
+                [.. known.Where(s => !loaded.Contains(s))],
+                known.Count > 0 ? [.. loaded.Where(s => !known.Contains(s)).Order()] : []
+            )
+        );
+    }
+}

backend/src/TeleWave.Application/Metadata/LoadedEpisodeNumbers.cs

@@ -0,0 +1,45 @@
+using TeleWave.Application.Library;
+using TeleWave.Domain.Library;
+
+namespace TeleWave.Application.Metadata;
+
+/// <summary>
+/// Что из сезонов/серий шоу реально загружено — общая основа отчётов об отсутствующем. Номера
+/// берутся проставленные, а при их отсутствии распознаются из имени файла (в отличие от обновления
+/// метаданных, распознанное не сохраняется: отчёты ничего не меняют).
+/// </summary>
+internal static class LoadedEpisodeNumbers
+{
+    /// <summary>Загруженные номера серий по сезонам — только сезоны, где есть хотя бы одна серия.</summary>
+    public static Dictionary<int, HashSet<int>> GroupBySeason(
+        Show show,
+        IReadOnlyDictionary<Guid, string> assetNames
+    )
+    {
+        var loadedBySeason = new Dictionary<int, HashSet<int>>();
+        foreach (var episode in show.Episodes)
+        {
+            if (Resolve(episode, assetNames) is not { } numbers)
+                continue;
+
+            if (!loadedBySeason.TryGetValue(numbers.Season, out var set))
+                loadedBySeason[numbers.Season] = set = [];
+            set.Add(numbers.Episode);
+        }
+        return loadedBySeason;
+    }
+
+    /// <summary>Сезон и номер серии: проставленные либо распознанные из имени файла; null — не вышло.</summary>
+    private static (int Season, int Episode)? Resolve(
+        ShowEpisode episode,
+        IReadOnlyDictionary<Guid, string> assetNames
+    )
+    {
+        if (episode.Season is { } season && episode.Episode is { } number)
+            return (season, number);
+
+        return assetNames.TryGetValue(episode.MediaAssetId, out var name)
+            ? EpisodeName.Parse(name)
+            : null;
+    }
+}

backend/src/TeleWave.Infrastructure/Metadata/OmdbMetadataProvider.cs

@@ -144,6 +144,26 @@ public sealed class OmdbMetadataProvider(
         return episodes.GetArrayLength();
     }
 
+    /// <summary>
+    /// OMDb перечня сезонов не отдаёт — только их количество (<c>totalSeasons</c>, строкой) в ответе
+    /// по id. Считаем сезоны сплошной нумерацией с единицы: разрывов в ней у OMDb не бывает.
+    /// </summary>
+    public async Task<IReadOnlyList<int>> GetSeasonNumbersAsync(
+        string externalId,
+        CancellationToken cancellationToken
+    )
+    {
+        var url = $"{_omdb.BaseUrl}/?apikey={_omdb.ApiKey}&i={Uri.EscapeDataString(externalId)}";
+        using var doc = await TryGetAsync(httpFactory, url, cancellationToken);
+        if (doc is null || !IsResponseTrue(doc.RootElement))
+            return [];
+
+        var total = Clean(GetString(doc.RootElement, "totalSeasons"));
+        return int.TryParse(total, CultureInfo.InvariantCulture, out var count) && count > 0
+            ? Enumerable.Range(1, count).ToList()
+            : [];
+    }
+
     private static bool IsResponseTrue(JsonElement root) =>
         GetString(root, "Response") is { } r
         && r.Equals("True", StringComparison.OrdinalIgnoreCase);

backend/src/TeleWave.Infrastructure/Metadata/TmdbMetadataProvider.cs

@@ -244,6 +244,32 @@ public sealed class TmdbMetadataProvider(
         return episodes.GetArrayLength();
     }
 
+    public async Task<IReadOnlyList<int>> GetSeasonNumbersAsync(
+        string externalId,
+        CancellationToken cancellationToken
+    )
+    {
+        var url =
+            $"{Tmdb.BaseUrl}/tv/{externalId}?api_key={Tmdb.ApiKey}&language={_options.Language}";
+        using var doc = await TryGetAsync(httpFactory, url, cancellationToken);
+        if (
+            doc is null
+            || !doc.RootElement.TryGetProperty("seasons", out var seasons)
+            || seasons.ValueKind != JsonValueKind.Array
+        )
+            return [];
+
+        var numbers = new List<int>();
+        foreach (var season in seasons.EnumerateArray())
+        {
+            // Нулевой сезон у TMDb — спецвыпуски; обычные сезоны нумеруются с единицы.
+            if (GetInt(season, "season_number") is { } number && number > 0)
+                numbers.Add(number);
+        }
+        numbers.Sort();
+        return numbers;
+    }
+
     private string? PosterUrl(string? path) =>
         string.IsNullOrEmpty(path) ? null : $"{Tmdb.ImageBaseUrl}/{Tmdb.PosterSize}{path}";
 

backend/tests/TeleWave.Application.Tests/Metadata/FindMissingSeasonsTests.cs

@@ -0,0 +1,154 @@
+using NSubstitute;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Metadata.FindMissingSeasons;
+using TeleWave.Application.Tests.Support;
+using TeleWave.Domain.Library;
+using Xunit;
+
+namespace TeleWave.Application.Tests.Metadata;
+
+public class FindMissingSeasonsTests
+{
+    [Fact]
+    public async Task ReportsSeasonsWithoutAnyLoadedEpisode()
+    {
+        var fixture = new TestDb();
+        var show = Show.Create("A", ShowKind.Series);
+        show.ApplyMetadata("tmdb", "123", "desc", 2000, null);
+        // Загружены сезоны 1 и 3; у источника их четыре — не хватает 2 и 4.
+        var e11 = show.AddEpisode(Guid.NewGuid());
+        e11.SetNumbers(1, 1);
+        var e31 = show.AddEpisode(Guid.NewGuid());
+        e31.SetNumbers(3, 1);
+
+        await using (var seed = fixture.New())
+        {
+            seed.Shows.Add(show);
+            await seed.SaveChangesAsync(CancellationToken.None);
+        }
+
+        var resolver = ResolverFor("123", [1, 2, 3, 4]);
+        await using var db = fixture.New();
+        var result = await new FindMissingSeasonsQueryHandler(db, resolver).Handle(
+            new FindMissingSeasonsQuery(show.Id),
+            CancellationToken.None
+        );
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal(4, result.Value.Expected);
+        Assert.Equal([1, 3], result.Value.Loaded);
+        Assert.Equal([2, 4], result.Value.Missing);
+        Assert.Empty(result.Value.Unknown);
+    }
+
+    [Fact]
+    public async Task ReportsLoadedSeasonsUnknownToSource()
+    {
+        var fixture = new TestDb();
+        var show = Show.Create("A", ShowKind.Series);
+        show.ApplyMetadata("tmdb", "123", null, 2000, null);
+        var e91 = show.AddEpisode(Guid.NewGuid());
+        e91.SetNumbers(9, 1);
+
+        await using (var seed = fixture.New())
+        {
+            seed.Shows.Add(show);
+            await seed.SaveChangesAsync(CancellationToken.None);
+        }
+
+        var resolver = ResolverFor("123", [1, 2]);
+        await using var db = fixture.New();
+        var result = await new FindMissingSeasonsQueryHandler(db, resolver).Handle(
+            new FindMissingSeasonsQuery(show.Id),
+            CancellationToken.None
+        );
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal([1, 2], result.Value.Missing);
+        Assert.Equal([9], result.Value.Unknown);
+    }
+
+    [Fact]
+    public async Task ReportsExpectedNull_WhenSourceReturnsNothing()
+    {
+        // Источник промолчал: ни отсутствующих, ни лишних сезонов утверждать нельзя.
+        var fixture = new TestDb();
+        var show = Show.Create("A", ShowKind.Series);
+        show.ApplyMetadata("tmdb", "123", null, 2000, null);
+        var e11 = show.AddEpisode(Guid.NewGuid());
+        e11.SetNumbers(1, 1);
+
+        await using (var seed = fixture.New())
+        {
+            seed.Shows.Add(show);
+            await seed.SaveChangesAsync(CancellationToken.None);
+        }
+
+        var resolver = ResolverFor("123", []);
+        await using var db = fixture.New();
+        var result = await new FindMissingSeasonsQueryHandler(db, resolver).Handle(
+            new FindMissingSeasonsQuery(show.Id),
+            CancellationToken.None
+        );
+
+        Assert.True(result.IsSuccess);
+        Assert.Null(result.Value.Expected);
+        Assert.Equal([1], result.Value.Loaded);
+        Assert.Empty(result.Value.Missing);
+        Assert.Empty(result.Value.Unknown);
+    }
+
+    [Fact]
+    public async Task Fails_ForNonSeries()
+    {
+        var fixture = new TestDb();
+        var show = Show.Create("A", ShowKind.Single);
+        show.ApplyMetadata("tmdb", "123", null, 2000, null);
+        await using (var seed = fixture.New())
+        {
+            seed.Shows.Add(show);
+            await seed.SaveChangesAsync(CancellationToken.None);
+        }
+
+        var resolver = Substitute.For<IMetadataProviderResolver>();
+        await using var db = fixture.New();
+        var result = await new FindMissingSeasonsQueryHandler(db, resolver).Handle(
+            new FindMissingSeasonsQuery(show.Id),
+            CancellationToken.None
+        );
+
+        Assert.False(result.IsSuccess);
+    }
+
+    [Fact]
+    public async Task Fails_WhenNoLinkedSource()
+    {
+        var fixture = new TestDb();
+        var show = Show.Create("A", ShowKind.Series);
+        await using (var seed = fixture.New())
+        {
+            seed.Shows.Add(show);
+            await seed.SaveChangesAsync(CancellationToken.None);
+        }
+
+        var resolver = Substitute.For<IMetadataProviderResolver>();
+        await using var db = fixture.New();
+        var result = await new FindMissingSeasonsQueryHandler(db, resolver).Handle(
+            new FindMissingSeasonsQuery(show.Id),
+            CancellationToken.None
+        );
+
+        Assert.False(result.IsSuccess);
+    }
+
+    private static IMetadataProviderResolver ResolverFor(string externalId, int[] seasons)
+    {
+        var provider = Substitute.For<IMetadataProvider>();
+        provider
+            .GetSeasonNumbersAsync(externalId, Arg.Any<CancellationToken>())
+            .Returns(seasons.ToList());
+        var resolver = Substitute.For<IMetadataProviderResolver>();
+        resolver.Resolve("tmdb").Returns(provider);
+        return resolver;
+    }
+}

frontend/src/features/admin/shows/ShowMetadataCard.tsx

@@ -3,7 +3,12 @@ import { useEffect, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import { Loader2 } from 'lucide-react'
 import { qk } from '@/shared/api/query-keys'
-import type { MetadataCandidate, MissingEpisodesReport, ShowDto } from '@/shared/api/types'
+import type {
+  MetadataCandidate,
+  MissingEpisodesReport,
+  MissingSeasonsReport,
+  ShowDto,
+} from '@/shared/api/types'
 import { useApiError } from '@/shared/lib/use-api-error'
 import { Badge } from '@/shared/ui/badge'
 import { Button } from '@/shared/ui/button'
@@ -19,6 +24,7 @@ import {
   applyMetadata,
   clearMetadata,
   findMissingEpisodes,
+  findMissingSeasons,
   getMetadataProviders,
   refreshEpisodesMetadata,
   renameShow,
@@ -132,6 +138,12 @@ export function ShowMetadataCard({
     onSuccess: (report) => setMissing(report),
     onError,
   })
+  const [missingSeasons, setMissingSeasons] = useState<MissingSeasonsReport | null>(null)
+  const findSeasons = useMutation({
+    mutationFn: () => findMissingSeasons(show.id),
+    onSuccess: (report) => setMissingSeasons(report),
+    onError,
+  })
 
   const linked =
     !!show.metadataExternalId && !!show.metadataProvider && show.metadataProvider !== 'manual'
@@ -319,6 +331,17 @@ export function ShowMetadataCard({
                     {t('admin.metadata.findMissing')}
                   </Button>
                 )}
+                {linked && show.kind === 'Series' && (
+                  <Button
+                    size="sm"
+                    variant="outline"
+                    disabled={findSeasons.isPending}
+                    onClick={() => findSeasons.mutate()}
+                  >
+                    {findSeasons.isPending && <Loader2 className="h-4 w-4 animate-spin" />}
+                    {t('admin.metadata.findMissingSeasons')}
+                  </Button>
+                )}
                 {(show.metadataProvider || show.posterImageId) && (
                   <Button
                     size="sm"
@@ -370,10 +393,53 @@ export function ShowMetadataCard({
           )}
         </DialogContent>
       </Dialog>
+
+      <Dialog
+        open={missingSeasons != null}
+        onOpenChange={(open) => !open && setMissingSeasons(null)}
+      >
+        <DialogContent className="max-w-lg">
+          <DialogHeader>
+            <DialogTitle>{t('admin.metadata.missingSeasonsTitle')}</DialogTitle>
+          </DialogHeader>
+          {missingSeasons && <MissingSeasonsBody report={missingSeasons} />}
+        </DialogContent>
+      </Dialog>
     </>
   )
 }
 
+/** Итог по сезонам: чего нет вовсе, что загружено сверх известного источнику. */
+function MissingSeasonsBody({ report }: Readonly<{ report: MissingSeasonsReport }>) {
+  const { t } = useTranslation()
+
+  if (report.expected == null)
+    return (
+      <p className="text-sm text-amber-500">{t('admin.metadata.missingSeasonsUnknownTotal')}</p>
+    )
+
+  return (
+    <div className="flex flex-col gap-2 text-sm">
+      <p className="text-xs text-muted-foreground">
+        {t('admin.metadata.loadedOf', { loaded: report.loaded.length, total: report.expected })}
+      </p>
+      {report.missing.length === 0 ? (
+        <p className="text-emerald-500">{t('admin.metadata.missingSeasonsNone')}</p>
+      ) : (
+        <p className="text-muted-foreground">
+          {t('admin.metadata.missingSeasonsList')}:{' '}
+          <span className="text-foreground">{report.missing.join(', ')}</span>
+        </p>
+      )}
+      {report.unknown.length > 0 && (
+        <p className="text-xs text-amber-500">
+          {t('admin.metadata.missingSeasonsUnknown', { list: report.unknown.join(', ') })}
+        </p>
+      )}
+    </div>
+  )
+}
+
 /** Итог по сезону: чего не хватает — или что полный состав сезона неизвестен. */
 function SeasonGapNote({ gap }: Readonly<{ gap: MissingEpisodesReport['seasons'][number] }>) {
   const { t } = useTranslation()

frontend/src/features/admin/shows/ShowsPanel.tsx

@@ -1,6 +1,6 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
 import { Link } from '@tanstack/react-router'
-import { useMemo, useState } from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import { qk } from '@/shared/api/query-keys'
 import {
@@ -244,7 +244,9 @@ export function ShowsPanel() {
                     <span className="text-muted-foreground">—</span>
                   )}
                 </td>
-                <td className="px-4 py-2 text-muted-foreground">{show.primaryGenre ?? '—'}</td>
+                <td className="px-4 py-2 text-muted-foreground">
+                  <GenreCell primary={show.primaryGenre} others={show.otherGenres} />
+                </td>
                 <td className="px-4 py-2 text-muted-foreground">{show.seasonCount}</td>
                 <td className="px-4 py-2 text-muted-foreground">{show.episodeCount}</td>
                 <td className="px-4 py-2">
@@ -266,3 +268,70 @@ export function ShowsPanel() {
     </div>
   )
 }
+
+/** Основной жанр шоу; остальные — под кнопкой «…», всплывающим списком. */
+function GenreCell({ primary, others }: Readonly<{ primary: string | null; others: string[] }>) {
+  const { t } = useTranslation()
+  const buttonRef = useRef<HTMLButtonElement>(null)
+  // Всплывашку позиционируем fixed по кнопке: таблица лежит в контейнере с overflow-x-auto,
+  // и absolute-список он обрезал бы по нижней границе. Прокрутка/ресайз сдвинули бы её мимо
+  // кнопки — на них просто закрываем.
+  const [at, setAt] = useState<{ left: number; top: number } | null>(null)
+
+  useEffect(() => {
+    if (at == null) return
+    const close = () => setAt(null)
+    window.addEventListener('scroll', close, true)
+    window.addEventListener('resize', close)
+    return () => {
+      window.removeEventListener('scroll', close, true)
+      window.removeEventListener('resize', close)
+    }
+  }, [at])
+
+  if (!primary) return <span>—</span>
+  if (others.length === 0) return <span>{primary}</span>
+
+  const toggle = () => {
+    if (at) {
+      setAt(null)
+      return
+    }
+    const rect = buttonRef.current?.getBoundingClientRect()
+    if (rect) setAt({ left: rect.left, top: rect.bottom + 4 })
+  }
+
+  return (
+    <span className="inline-flex items-center gap-1.5">
+      {primary}
+      <button
+        ref={buttonRef}
+        type="button"
+        title={t('admin.shows.otherGenres')}
+        aria-label={t('admin.shows.otherGenres')}
+        aria-expanded={at != null}
+        className="rounded-sm border border-border px-1 text-xs leading-tight hover:border-primary/60 hover:text-foreground"
+        onClick={toggle}
+        onBlur={() => setAt(null)}
+        onKeyDown={(e) => e.key === 'Escape' && setAt(null)}
+      >
+        …
+      </button>
+      {at && (
+        <div
+          className="crt-panel fixed z-50 max-w-56 rounded-md border border-border bg-background px-2 py-1.5 text-xs"
+          style={{ left: at.left, top: at.top }}
+        >
+          <p className="mb-1 text-[10px] uppercase tracking-wide text-muted-foreground">
+            {t('admin.shows.otherGenres')}
+          </p>
+          <ul className="flex flex-col gap-0.5 text-foreground">
+            {others.map((genre) => (
+              <li key={genre}>{genre}</li>
+            ))}
+          </ul>
+        </div>
+      )}
+    </span>
+  )
+}

frontend/src/features/admin/shows/api.ts

@@ -3,6 +3,7 @@ import type {
   CreatedIdResponse,
   MetadataCandidate,
   MissingEpisodesReport,
+  MissingSeasonsReport,
   ShowAudience,
   ShowDto,
   ShowKind,
@@ -114,3 +115,8 @@ export function refreshEpisodesMetadata(showId: string) {
 export function findMissingEpisodes(showId: string) {
   return apiRequest<MissingEpisodesReport>(`/admin/metadata/shows/${showId}/missing-episodes`)
 }
+
+/** Отчёт: каких сезонов нет в библиотеке вовсе (по данным источника). */
+export function findMissingSeasons(showId: string) {
+  return apiRequest<MissingSeasonsReport>(`/admin/metadata/shows/${showId}/missing-seasons`)
+}

frontend/src/shared/api/types.ts

@@ -154,8 +154,10 @@ export type ShowSummaryDto = {
   year: number | null
   hasPoster: boolean
   createdAt: string
-  /** Основной жанр — в списке показывается только он. */
+  /** Основной жанр — его показывает колонка списка. */
   primaryGenre: string | null
+  /** Прочие жанры — в списке прячутся под «…». */
+  otherGenres: string[]
 }
 
 type ShowGenreDto = {
@@ -310,6 +312,17 @@ export type MissingEpisodesReport = {
   seasons: SeasonGapDto[]
 }
 
+export type MissingSeasonsReport = {
+  /** Сколько сезонов у сериала по источнику; null — источник не отдал данные. */
+  expected: number | null
+  /** Номера сезонов, где загружена хотя бы одна серия. */
+  loaded: number[]
+  /** Номера сезонов из источника, где не загружено ни одной серии. */
+  missing: number[]
+  /** Загруженные сезоны, которых источник не знает. */
+  unknown: number[]
+}
+
 type EpisodeDto = {
   id: string
   mediaAssetId: string

frontend/src/shared/lib/locales/en.ts

@@ -308,6 +308,7 @@ export const en = {
       loadedSeasons: 'Loaded seasons',
       genre: 'Genre',
       allGenres: 'All genres',
+      otherGenres: 'Other genres',
       genresEmpty: 'No genres set',
       genresEdit: 'Genres',
       genresHint:
@@ -676,6 +677,12 @@ export const en = {
       missingUnknown: 'The source did not return the episode count for this season.',
       missingNone: 'All episodes present.',
       missingList: 'Missing',
+      findMissingSeasons: 'Find missing seasons',
+      missingSeasonsTitle: 'Missing seasons',
+      missingSeasonsUnknownTotal: 'The source did not return the season list for this series.',
+      missingSeasonsNone: 'All seasons present.',
+      missingSeasonsList: 'Seasons with no loaded episodes',
+      missingSeasonsUnknown: 'The source does not know these loaded seasons: {{list}}.',
     },
   },
 }

frontend/src/shared/lib/locales/ru.ts

@@ -309,6 +309,7 @@ export const ru = {
       loadedSeasons: 'Загружены сезоны',
       genre: 'Жанр',
       allGenres: 'Все жанры',
+      otherGenres: 'Остальные жанры',
       genresEmpty: 'Жанры не проставлены',
       genresEdit: 'Жанры',
       genresHint:
@@ -682,6 +683,12 @@ export const ru = {
       missingUnknown: 'Источник не отдал число серий этого сезона.',
       missingNone: 'Все серии на месте.',
       missingList: 'Не хватает',
+      findMissingSeasons: 'Найти отсутствующие сезоны',
+      missingSeasonsTitle: 'Отсутствующие сезоны',
+      missingSeasonsUnknownTotal: 'Источник не отдал список сезонов этого сериала.',
+      missingSeasonsNone: 'Все сезоны на месте.',
+      missingSeasonsList: 'Не загружено ни одной серии из сезонов',
+      missingSeasonsUnknown: 'Источник не знает загруженные сезоны: {{list}}.',
     },
   },
 }