Add metadata management for shows: implement metadata retrieval, application, and updates in the API and UI. Enhance Show and ShowDto models to include metadata fields, and update the database schema accordingly. Introduce new endpoints for metadata operations and integrate metadata display in the ShowDetail component.

backend/src/TeleWave.Infrastructure/DependencyInjection.cs

@@ -13,6 +13,7 @@ using TeleWave.Domain.Broadcast.Scheduling;
 using TeleWave.Infrastructure.Broadcast;
 using TeleWave.Infrastructure.Identity;
 using TeleWave.Infrastructure.Media;
+using TeleWave.Infrastructure.Metadata;
 using TeleWave.Infrastructure.Persistence;
 using TeleWave.Infrastructure.Settings;
 using TeleWave.Infrastructure.Streaming;
@@ -96,10 +97,22 @@ public static class DependencyInjection
 
         AddMedia(services, configuration);
         AddBroadcast(services, configuration);
+        AddMetadata(services, configuration);
 
         return services;
     }
 
+    /// <summary>Метаданные шоу/серий: провайдеры TMDb/OMDb, резолвер, локальное хранилище картинок.</summary>
+    private static void AddMetadata(IServiceCollection services, IConfiguration configuration)
+    {
+        services.Configure<MetadataOptions>(configuration.GetSection(MetadataOptions.SectionName));
+        services.AddHttpClient("metadata", client => client.Timeout = TimeSpan.FromSeconds(15));
+        services.AddSingleton<IMetadataProvider, TmdbMetadataProvider>();
+        services.AddSingleton<IMetadataProvider, OmdbMetadataProvider>();
+        services.AddSingleton<IMetadataProviderResolver, MetadataProviderResolver>();
+        services.AddSingleton<IMetadataImageStore, MetadataImageStore>();
+    }
+
     /// <summary>Планировщик расписания: генератор, источник случайности и фоновый сервис горизонта.</summary>
     private static void AddBroadcast(IServiceCollection services, IConfiguration configuration)
     {

backend/src/TeleWave.Infrastructure/Media/MediaPathResolver.cs

@@ -18,6 +18,7 @@ public sealed class MediaPathResolver
         OriginalsDir = Path.Combine(_root, "originals");
         AssetsDir = Path.Combine(_root, "assets");
         BumpersDir = Path.Combine(_root, "bumpers");
+        MetadataDir = Path.Combine(_root, "metadata");
     }
 
     public string InboxDir { get; }
@@ -28,6 +29,9 @@ public sealed class MediaPathResolver
     /// <summary>Сырые файлы шаблонов заставок (фон/музыка) по каналам — не режутся на HLS.</summary>
     public string BumpersDir { get; }
 
+    /// <summary>Картинки метаданных (постеры/кадры), скачанные локально.</summary>
+    public string MetadataDir { get; }
+
     public void EnsureDirectories()
     {
         Directory.CreateDirectory(InboxDir);
@@ -35,6 +39,33 @@ public sealed class MediaPathResolver
         Directory.CreateDirectory(OriginalsDir);
         Directory.CreateDirectory(AssetsDir);
         Directory.CreateDirectory(BumpersDir);
+        Directory.CreateDirectory(MetadataDir);
+    }
+
+    public string MetadataShowDir(Guid showId) =>
+        EnsureWithinRoot(Path.Combine(MetadataDir, "shows", showId.ToString("N")));
+
+    /// <summary>Абсолютный путь к файлу постера шоу (extension — с точкой).</summary>
+    public string MetadataShowPosterPath(Guid showId, string extension) =>
+        EnsureWithinRoot(
+            Path.Combine(MetadataDir, "shows", showId.ToString("N"), "poster" + extension)
+        );
+
+    /// <summary>Относительный путь постера от корня (для хранения в БД и отдачи).</summary>
+    public string MetadataShowPosterRelative(Guid showId, string extension) =>
+        $"metadata/shows/{showId:N}/poster{extension}";
+
+    /// <summary>Абсолютный путь по относительному (с защитой от traversal) или null, если вне корня.</summary>
+    public string? ResolveRelative(string relativePath)
+    {
+        try
+        {
+            return EnsureWithinRoot(Path.Combine(_root, relativePath));
+        }
+        catch (UnauthorizedAccessException)
+        {
+            return null;
+        }
     }
 
     public string BumperChannelDir(Guid channelId) =>

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

@@ -0,0 +1,88 @@
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Infrastructure.Media;
+
+namespace TeleWave.Infrastructure.Metadata;
+
+/// <summary>Скачивает и хранит картинки метаданных локально под metadata/shows/{id}.</summary>
+public sealed class MetadataImageStore(MediaPathResolver paths, IHttpClientFactory httpFactory)
+    : IMetadataImageStore
+{
+    public async Task<string?> DownloadShowPosterAsync(
+        Guid showId,
+        string url,
+        CancellationToken cancellationToken
+    )
+    {
+        try
+        {
+            var client = httpFactory.CreateClient("metadata");
+            using var response = await client.GetAsync(url, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+                return null;
+
+            var ext = ExtensionFor(url, response.Content.Headers.ContentType?.MediaType);
+            await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+            return await WritePosterAsync(showId, ext, content, cancellationToken);
+        }
+        catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException or IOException)
+        {
+            return null;
+        }
+    }
+
+    public Task<string> SaveShowPosterAsync(
+        Guid showId,
+        string extension,
+        Stream content,
+        CancellationToken cancellationToken
+    ) => WritePosterAsync(showId, NormalizeExtension(extension), content, cancellationToken);
+
+    public void DeleteShowImages(Guid showId)
+    {
+        var dir = paths.MetadataShowDir(showId);
+        if (Directory.Exists(dir))
+            Directory.Delete(dir, recursive: true);
+    }
+
+    public string? ResolveAbsolutePath(string relativePath)
+    {
+        var abs = paths.ResolveRelative(relativePath);
+        return abs is not null && File.Exists(abs) ? abs : null;
+    }
+
+    private async Task<string> WritePosterAsync(
+        Guid showId,
+        string ext,
+        Stream content,
+        CancellationToken cancellationToken
+    )
+    {
+        var dir = paths.MetadataShowDir(showId);
+        Directory.CreateDirectory(dir);
+        RemoveExisting(dir, "poster");
+
+        var abs = paths.MetadataShowPosterPath(showId, ext);
+        await using (var fs = File.Create(abs))
+            await content.CopyToAsync(fs, cancellationToken);
+
+        return paths.MetadataShowPosterRelative(showId, ext);
+    }
+
+    private static void RemoveExisting(string dir, string baseName)
+    {
+        foreach (var file in Directory.EnumerateFiles(dir, baseName + ".*"))
+            File.Delete(file);
+    }
+
+    private static string ExtensionFor(string url, string? mediaType) =>
+        mediaType switch
+        {
+            "image/png" => ".png",
+            "image/webp" => ".webp",
+            "image/jpeg" => ".jpg",
+            _ => Path.GetExtension(new Uri(url).AbsolutePath) is { Length: > 1 } e ? e.ToLowerInvariant() : ".jpg",
+        };
+
+    private static string NormalizeExtension(string extension) =>
+        extension.StartsWith('.') ? extension.ToLowerInvariant() : "." + extension.ToLowerInvariant();
+}

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

@@ -0,0 +1,27 @@
+namespace TeleWave.Infrastructure.Metadata;
+
+public sealed class MetadataOptions
+{
+    public const string SectionName = "Metadata";
+
+    /// <summary>Язык метаданных (ISO, например «ru-RU»).</summary>
+    public string Language { get; init; } = "ru-RU";
+
+    public TmdbOptions Tmdb { get; init; } = new();
+    public OmdbOptions Omdb { get; init; } = new();
+}
+
+public sealed class TmdbOptions
+{
+    public string ApiKey { get; init; } = string.Empty;
+    public string BaseUrl { get; init; } = "https://api.themoviedb.org/3";
+    public string ImageBaseUrl { get; init; } = "https://image.tmdb.org/t/p";
+    public string PosterSize { get; init; } = "w500";
+    public string StillSize { get; init; } = "w300";
+}
+
+public sealed class OmdbOptions
+{
+    public string ApiKey { get; init; } = string.Empty;
+    public string BaseUrl { get; init; } = "https://www.omdbapi.com";
+}

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

@@ -0,0 +1,32 @@
+using Microsoft.Extensions.Options;
+using TeleWave.Application.Common.Interfaces;
+
+namespace TeleWave.Infrastructure.Metadata;
+
+/// <summary>Резолвит провайдеры по ключу; доступными считает только те, у кого задан API-ключ.</summary>
+public sealed class MetadataProviderResolver : IMetadataProviderResolver
+{
+    private readonly Dictionary<string, IMetadataProvider> _byKey;
+    private readonly List<string> _available = new();
+
+    public MetadataProviderResolver(
+        IEnumerable<IMetadataProvider> providers,
+        IOptions<MetadataOptions> options
+    )
+    {
+        _byKey = providers.ToDictionary(p => p.Key, StringComparer.OrdinalIgnoreCase);
+        var opt = options.Value;
+        if (_byKey.ContainsKey("tmdb") && !string.IsNullOrWhiteSpace(opt.Tmdb.ApiKey))
+            _available.Add("tmdb");
+        if (_byKey.ContainsKey("omdb") && !string.IsNullOrWhiteSpace(opt.Omdb.ApiKey))
+            _available.Add("omdb");
+    }
+
+    public IMetadataProvider? Resolve(string key) =>
+        _available.Contains(key, StringComparer.OrdinalIgnoreCase)
+        && _byKey.TryGetValue(key, out var provider)
+            ? provider
+            : null;
+
+    public IReadOnlyList<string> AvailableKeys => _available;
+}

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

@@ -0,0 +1,122 @@
+using System.Globalization;
+using System.Text.Json;
+using Microsoft.Extensions.Options;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Metadata;
+
+namespace TeleWave.Infrastructure.Metadata;
+
+/// <summary>Провайдер метаданных OMDb (omdbapi.com, данные IMDb). Требует API-ключ.</summary>
+public sealed class OmdbMetadataProvider(IHttpClientFactory httpFactory, IOptions<MetadataOptions> options)
+    : IMetadataProvider
+{
+    private readonly OmdbOptions _omdb = options.Value.Omdb;
+
+    public string Key => "omdb";
+
+    public async Task<IReadOnlyList<MetadataCandidate>> SearchShowsAsync(
+        string query,
+        CancellationToken cancellationToken
+    )
+    {
+        var url = $"{_omdb.BaseUrl}/?apikey={_omdb.ApiKey}&type=series&s={Uri.EscapeDataString(query)}";
+        using var doc = await GetJsonAsync(url, cancellationToken);
+        if (doc is null || !doc.RootElement.TryGetProperty("Search", out var search))
+            return [];
+
+        var list = new List<MetadataCandidate>();
+        foreach (var item in search.EnumerateArray())
+        {
+            var id = Clean(GetString(item, "imdbID"));
+            if (id is null)
+                continue;
+            list.Add(
+                new MetadataCandidate(
+                    id,
+                    Clean(GetString(item, "Title")) ?? "—",
+                    YearFrom(GetString(item, "Year")),
+                    null,
+                    Clean(GetString(item, "Poster"))
+                )
+            );
+        }
+        return list;
+    }
+
+    public async Task<ShowMetadata?> GetShowAsync(string externalId, CancellationToken cancellationToken)
+    {
+        var url = $"{_omdb.BaseUrl}/?apikey={_omdb.ApiKey}&i={Uri.EscapeDataString(externalId)}";
+        using var doc = await GetJsonAsync(url, cancellationToken);
+        if (doc is null || !IsResponseTrue(doc.RootElement))
+            return null;
+        var root = doc.RootElement;
+        return new ShowMetadata(
+            externalId,
+            Clean(GetString(root, "Title")) ?? "—",
+            YearFrom(GetString(root, "Year")),
+            Clean(GetString(root, "Plot")),
+            Clean(GetString(root, "Poster"))
+        );
+    }
+
+    public async Task<EpisodeMetadata?> GetEpisodeAsync(
+        string externalId,
+        int season,
+        int episode,
+        CancellationToken cancellationToken
+    )
+    {
+        var url =
+            $"{_omdb.BaseUrl}/?apikey={_omdb.ApiKey}&i={Uri.EscapeDataString(externalId)}"
+            + $"&Season={season}&Episode={episode}";
+        using var doc = await GetJsonAsync(url, cancellationToken);
+        if (doc is null || !IsResponseTrue(doc.RootElement))
+            return null;
+        var root = doc.RootElement;
+        return new EpisodeMetadata(
+            Clean(GetString(root, "Title")) ?? "—",
+            Clean(GetString(root, "Plot")),
+            Clean(GetString(root, "Poster")),
+            DateFrom(GetString(root, "Released"))
+        );
+    }
+
+    private async Task<JsonDocument?> GetJsonAsync(string url, CancellationToken cancellationToken)
+    {
+        var client = httpFactory.CreateClient("metadata");
+        try
+        {
+            using var response = await client.GetAsync(url, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+                return null;
+            var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+            return await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken);
+        }
+        catch (Exception ex) when (ex is HttpRequestException or JsonException or TaskCanceledException)
+        {
+            return null;
+        }
+    }
+
+    private static bool IsResponseTrue(JsonElement root) =>
+        GetString(root, "Response") is { } r && r.Equals("True", StringComparison.OrdinalIgnoreCase);
+
+    private static string? GetString(JsonElement el, string name) =>
+        el.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String ? v.GetString() : null;
+
+    /// <summary>OMDb отдаёт «N/A» вместо отсутствующих значений — приводим к null.</summary>
+    private static string? Clean(string? value) =>
+        string.IsNullOrWhiteSpace(value) || value == "N/A" ? null : value;
+
+    private static int? YearFrom(string? year)
+    {
+        if (year is { Length: >= 4 } && int.TryParse(year.AsSpan(0, 4), out var y))
+            return y;
+        return null;
+    }
+
+    private static DateOnly? DateFrom(string? released) =>
+        DateTime.TryParse(released, CultureInfo.InvariantCulture, DateTimeStyles.None, out var dt)
+            ? DateOnly.FromDateTime(dt)
+            : null;
+}

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

@@ -0,0 +1,122 @@
+using System.Globalization;
+using System.Text.Json;
+using Microsoft.Extensions.Options;
+using TeleWave.Application.Common.Interfaces;
+using TeleWave.Application.Metadata;
+
+namespace TeleWave.Infrastructure.Metadata;
+
+/// <summary>Провайдер метаданных TMDb (themoviedb.org). Требует API-ключ (v3).</summary>
+public sealed class TmdbMetadataProvider(IHttpClientFactory httpFactory, IOptions<MetadataOptions> options)
+    : IMetadataProvider
+{
+    private readonly MetadataOptions _options = options.Value;
+
+    public string Key => "tmdb";
+
+    private TmdbOptions Tmdb => _options.Tmdb;
+
+    public async Task<IReadOnlyList<MetadataCandidate>> SearchShowsAsync(
+        string query,
+        CancellationToken cancellationToken
+    )
+    {
+        var url =
+            $"{Tmdb.BaseUrl}/search/tv?api_key={Tmdb.ApiKey}&language={_options.Language}"
+            + $"&include_adult=false&query={Uri.EscapeDataString(query)}";
+        using var doc = await GetJsonAsync(url, cancellationToken);
+        if (doc is null || !doc.RootElement.TryGetProperty("results", out var results))
+            return [];
+
+        var list = new List<MetadataCandidate>();
+        foreach (var item in results.EnumerateArray())
+        {
+            var id = GetInt(item, "id");
+            if (id is null)
+                continue;
+            list.Add(
+                new MetadataCandidate(
+                    id.Value.ToString(CultureInfo.InvariantCulture),
+                    GetString(item, "name") ?? "—",
+                    YearFrom(GetString(item, "first_air_date")),
+                    GetString(item, "overview"),
+                    PosterUrl(GetString(item, "poster_path"))
+                )
+            );
+        }
+        return list;
+    }
+
+    public async Task<ShowMetadata?> GetShowAsync(string externalId, CancellationToken cancellationToken)
+    {
+        var url = $"{Tmdb.BaseUrl}/tv/{externalId}?api_key={Tmdb.ApiKey}&language={_options.Language}";
+        using var doc = await GetJsonAsync(url, cancellationToken);
+        if (doc is null)
+            return null;
+        var root = doc.RootElement;
+        return new ShowMetadata(
+            externalId,
+            GetString(root, "name") ?? "—",
+            YearFrom(GetString(root, "first_air_date")),
+            GetString(root, "overview"),
+            PosterUrl(GetString(root, "poster_path"))
+        );
+    }
+
+    public async Task<EpisodeMetadata?> GetEpisodeAsync(
+        string externalId,
+        int season,
+        int episode,
+        CancellationToken cancellationToken
+    )
+    {
+        var url =
+            $"{Tmdb.BaseUrl}/tv/{externalId}/season/{season}/episode/{episode}"
+            + $"?api_key={Tmdb.ApiKey}&language={_options.Language}";
+        using var doc = await GetJsonAsync(url, cancellationToken);
+        if (doc is null)
+            return null;
+        var root = doc.RootElement;
+        return new EpisodeMetadata(
+            GetString(root, "name") ?? "—",
+            GetString(root, "overview"),
+            StillUrl(GetString(root, "still_path")),
+            DateFrom(GetString(root, "air_date"))
+        );
+    }
+
+    private string? PosterUrl(string? path) =>
+        string.IsNullOrEmpty(path) ? null : $"{Tmdb.ImageBaseUrl}/{Tmdb.PosterSize}{path}";
+
+    private string? StillUrl(string? path) =>
+        string.IsNullOrEmpty(path) ? null : $"{Tmdb.ImageBaseUrl}/{Tmdb.StillSize}{path}";
+
+    private async Task<JsonDocument?> GetJsonAsync(string url, CancellationToken cancellationToken)
+    {
+        var client = httpFactory.CreateClient("metadata");
+        try
+        {
+            using var response = await client.GetAsync(url, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+                return null;
+            var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+            return await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken);
+        }
+        catch (Exception ex) when (ex is HttpRequestException or JsonException or TaskCanceledException)
+        {
+            return null;
+        }
+    }
+
+    private static string? GetString(JsonElement el, string name) =>
+        el.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String ? v.GetString() : null;
+
+    private static int? GetInt(JsonElement el, string name) =>
+        el.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.Number ? v.GetInt32() : null;
+
+    private static int? YearFrom(string? date) =>
+        date is { Length: >= 4 } && int.TryParse(date.AsSpan(0, 4), out var y) ? y : null;
+
+    private static DateOnly? DateFrom(string? date) =>
+        DateOnly.TryParse(date, CultureInfo.InvariantCulture, out var d) ? d : null;
+}

backend/src/TeleWave.Infrastructure/Migrations/20260725055823_ShowMetadata.Designer.cs

@@ -0,0 +1,827 @@
+// <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("20260725055823_ShowMetadata")]
+    partial class ShowMetadata
+    {
+        /// <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>("MetadataExternalId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MetadataProvider")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PosterPath")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("integer");
+
+                    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/20260725055823_ShowMetadata.cs

@@ -0,0 +1,61 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TeleWave.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class ShowMetadata : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "MetadataExternalId",
+                table: "Shows",
+                type: "character varying(64)",
+                maxLength: 64,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "MetadataProvider",
+                table: "Shows",
+                type: "character varying(16)",
+                maxLength: 16,
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "PosterPath",
+                table: "Shows",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "Year",
+                table: "Shows",
+                type: "integer",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "MetadataExternalId",
+                table: "Shows");
+
+            migrationBuilder.DropColumn(
+                name: "MetadataProvider",
+                table: "Shows");
+
+            migrationBuilder.DropColumn(
+                name: "PosterPath",
+                table: "Shows");
+
+            migrationBuilder.DropColumn(
+                name: "Year",
+                table: "Shows");
+        }
+    }
+}

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

@@ -458,11 +458,26 @@ namespace TeleWave.Infrastructure.Migrations
                     b.Property<int>("Kind")
                         .HasColumnType("integer");
 
+                    b.Property<string>("MetadataExternalId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("MetadataProvider")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
                     b.Property<string>("Name")
                         .IsRequired()
                         .HasMaxLength(256)
                         .HasColumnType("character varying(256)");
 
+                    b.Property<string>("PosterPath")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("integer");
+
                     b.HasKey("Id");
 
                     b.ToTable("Shows");

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

@@ -11,6 +11,9 @@ public class ShowConfiguration : IEntityTypeConfiguration<Show>
     {
         builder.Property(x => x.Name).IsRequired().HasMaxLength(256);
         builder.Property(x => x.Description).HasMaxLength(2048);
+        builder.Property(x => x.MetadataProvider).HasMaxLength(16);
+        builder.Property(x => x.MetadataExternalId).HasMaxLength(64);
+        builder.Property(x => x.PosterPath).HasMaxLength(256);
 
         builder
             .HasMany(x => x.Episodes)

backend/src/TeleWave.Infrastructure/TeleWave.Infrastructure.csproj

@@ -11,6 +11,7 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
+    <PackageReference Include="Microsoft.Extensions.Http" />
     <PackageReference Include="Microsoft.Extensions.Options" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
     <PackageReference Include="System.IdentityModel.Tokens.Jwt" />