379 lines
15 KiB
C#
379 lines
15 KiB
C#
using System.Globalization;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Channels;
|
|
using ErsatzTV.Application.Subtitles;
|
|
using ErsatzTV.Core;
|
|
using ErsatzTV.Core.Domain;
|
|
using ErsatzTV.Core.Domain.Filler;
|
|
using ErsatzTV.Core.Errors;
|
|
using ErsatzTV.Core.Interfaces.Images;
|
|
using ErsatzTV.Core.Interfaces.Search;
|
|
using ErsatzTV.Infrastructure.Data;
|
|
using ErsatzTV.Infrastructure.Extensions;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using static ErsatzTV.Application.Channels.ChannelValidations;
|
|
using static ErsatzTV.Application.Channels.Mapper;
|
|
using Channel = ErsatzTV.Core.Domain.Channel;
|
|
|
|
namespace ErsatzTV.Application.Channels;
|
|
|
|
public class UpdateChannelHandler(
|
|
ChannelWriter<IBackgroundServiceRequest> workerChannel,
|
|
IDbContextFactory<TvContext> dbContextFactory,
|
|
ISearchTargets searchTargets,
|
|
IRemoteLogoCacher remoteLogoCacher)
|
|
: IRequestHandler<UpdateChannel, Either<BaseError, ChannelViewModel>>
|
|
{
|
|
public async Task<Either<BaseError, ChannelViewModel>> Handle(
|
|
UpdateChannel request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
Option<Channel> maybeChannel = await dbContext.Channels
|
|
.Include(c => c.Artwork)
|
|
.Include(c => c.Watermark)
|
|
.Include(c => c.Playouts)
|
|
.Include(c => c.ChannelGraphicsElements)
|
|
.SelectOneAsync(c => c.Id, c => c.Id == request.ChannelId, cancellationToken);
|
|
|
|
return await maybeChannel.Match(
|
|
Some: async channel =>
|
|
{
|
|
Validation<BaseError, Channel> validation =
|
|
await Validate(dbContext, request, channel, cancellationToken);
|
|
return await validation.Match(
|
|
Succ: async c =>
|
|
{
|
|
Either<BaseError, string> resolvedLogo = await ResolveLogoPath(request, cancellationToken);
|
|
return await resolvedLogo.Match(
|
|
Right: async logoPath => Right<BaseError, ChannelViewModel>(
|
|
await ApplyUpdateRequest(dbContext, c, request, logoPath, cancellationToken)),
|
|
Left: e => Task.FromResult(Left<BaseError, ChannelViewModel>(e)));
|
|
},
|
|
Fail: errors => Task.FromResult(Left<BaseError, ChannelViewModel>(errors.Join())));
|
|
},
|
|
None: () => Task.FromResult(
|
|
Left<BaseError, ChannelViewModel>(
|
|
new NotFoundError($"Channel {request.ChannelId} does not exist."))));
|
|
}
|
|
|
|
// Resolve the incoming logo path into a value safe to persist. An external http(s) URL is
|
|
// downloaded and cached (a cacher Left fails the whole save); an empty path (logo removal) or an
|
|
// already-local/cached path passes through unchanged. (ersatztv#525)
|
|
private async Task<Either<BaseError, string>> ResolveLogoPath(
|
|
UpdateChannel request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
string path = request.Logo?.Path ?? string.Empty;
|
|
|
|
if (!Artwork.IsExternalUrl(path))
|
|
{
|
|
return path;
|
|
}
|
|
|
|
Either<BaseError, string> cached = await remoteLogoCacher.CacheFromUrl(new Uri(path), cancellationToken);
|
|
return cached;
|
|
}
|
|
|
|
private async Task<ChannelViewModel> ApplyUpdateRequest(
|
|
TvContext dbContext,
|
|
Channel c,
|
|
UpdateChannel update,
|
|
string resolvedLogoPath,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
bool hasEpgChange = c.PlayoutSource != update.PlayoutSource || c.ShowInEpg != update.ShowInEpg;
|
|
|
|
c.Name = update.Name;
|
|
c.Number = update.Number;
|
|
c.SortNumber = double.Parse(update.Number, CultureInfo.InvariantCulture);
|
|
c.Group = update.Group;
|
|
c.Categories = update.Categories;
|
|
c.FFmpegProfileId = update.FFmpegProfileId;
|
|
c.SlugSeconds = update.SlugSeconds;
|
|
c.StreamSelectorMode = update.StreamSelectorMode;
|
|
c.StreamSelector = update.StreamSelector;
|
|
c.PreferredAudioLanguageCode = update.PreferredAudioLanguageCode;
|
|
c.PreferredAudioTitle = update.PreferredAudioTitle;
|
|
c.PreferredSubtitleLanguageCode = update.PreferredSubtitleLanguageCode;
|
|
c.SubtitleMode = update.SubtitleMode;
|
|
c.MusicVideoCreditsMode = update.MusicVideoCreditsMode;
|
|
c.MusicVideoCreditsTemplate = update.MusicVideoCreditsTemplate;
|
|
c.SongVideoMode = update.SongVideoMode;
|
|
c.TranscodeMode = update.TranscodeMode;
|
|
c.IdleBehavior = update.IdleBehavior;
|
|
c.IsEnabled = update.IsEnabled;
|
|
c.ShowInEpg = update.IsEnabled && update.ShowInEpg;
|
|
c.Artwork ??= [];
|
|
|
|
if (!string.IsNullOrWhiteSpace(resolvedLogoPath))
|
|
{
|
|
string logo = resolvedLogoPath;
|
|
if (logo.StartsWith("iptv/logos/", StringComparison.Ordinal))
|
|
{
|
|
logo = logo.Replace("iptv/logos/", string.Empty);
|
|
}
|
|
|
|
Option<Artwork> maybeLogo = c.Artwork.Where(a => a.ArtworkKind == ArtworkKind.Logo).HeadOrNone();
|
|
foreach (Artwork artwork in maybeLogo)
|
|
{
|
|
artwork.Path = logo;
|
|
artwork.OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
|
|
? update.Logo.ContentType
|
|
: null;
|
|
artwork.DateUpdated = DateTime.UtcNow;
|
|
}
|
|
|
|
if (maybeLogo.IsNone)
|
|
{
|
|
var artwork = new Artwork
|
|
{
|
|
Path = logo,
|
|
OriginalContentType = !string.IsNullOrEmpty(update.Logo.ContentType)
|
|
? update.Logo.ContentType
|
|
: null,
|
|
DateAdded = DateTime.UtcNow,
|
|
DateUpdated = DateTime.UtcNow,
|
|
ArtworkKind = ArtworkKind.Logo
|
|
};
|
|
c.Artwork.Add(artwork);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await dbContext.Entry(c)
|
|
.Collection(channel => channel.Artwork)
|
|
.LoadAsync(cancellationToken);
|
|
|
|
foreach (Artwork artwork in c.Artwork.Where(x => x.ArtworkKind is ArtworkKind.Logo).ToList())
|
|
{
|
|
c.Artwork.Remove(artwork);
|
|
dbContext.Artwork.Remove(artwork);
|
|
}
|
|
}
|
|
|
|
c.PlayoutSource = update.PlayoutSource;
|
|
c.PlayoutMode = update.PlayoutMode;
|
|
|
|
if (c.PlayoutSource is ChannelPlayoutSource.Mirror)
|
|
{
|
|
c.PlayoutMode = ChannelPlayoutMode.Continuous;
|
|
hasEpgChange |= c.MirrorSourceChannelId != update.MirrorSourceChannelId;
|
|
hasEpgChange |= c.PlayoutOffset != update.PlayoutOffset;
|
|
c.MirrorSourceChannelId = update.MirrorSourceChannelId;
|
|
c.PlayoutOffset = update.PlayoutOffset;
|
|
}
|
|
else
|
|
{
|
|
c.MirrorSourceChannelId = null;
|
|
c.PlayoutOffset = null;
|
|
}
|
|
|
|
c.StreamingMode = update.StreamingMode;
|
|
c.WatermarkId = update.WatermarkId;
|
|
c.FallbackFillerId = update.FallbackFillerId;
|
|
|
|
c.ChannelGraphicsElements ??= [];
|
|
var desired = update.GraphicsElementIds?.Distinct().ToList() ?? [];
|
|
c.ChannelGraphicsElements.RemoveAll(cge => !desired.Contains(cge.GraphicsElementId));
|
|
foreach (int id in desired.Where(id => c.ChannelGraphicsElements.All(cge => cge.GraphicsElementId != id)))
|
|
{
|
|
c.ChannelGraphicsElements.Add(new ChannelGraphicsElement { ChannelId = c.Id, GraphicsElementId = id });
|
|
}
|
|
|
|
await dbContext.SaveChangesAsync(cancellationToken);
|
|
|
|
searchTargets.SearchTargetsChanged();
|
|
|
|
// post-commit side effect runs on CancellationToken.None so a late request cancellation
|
|
// can't abort it after the commit landed (#254)
|
|
if (c.SubtitleMode != ChannelSubtitleMode.None)
|
|
{
|
|
Option<Playout> maybePlayout = await dbContext.Playouts
|
|
.SelectOneAsync(p => p.ChannelId, p => p.ChannelId == c.Id, CancellationToken.None);
|
|
|
|
foreach (Playout playout in maybePlayout)
|
|
{
|
|
await workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id), CancellationToken.None);
|
|
}
|
|
}
|
|
|
|
await workerChannel.WriteAsync(new RefreshChannelList(), CancellationToken.None);
|
|
if (hasEpgChange)
|
|
{
|
|
await workerChannel.WriteAsync(new RefreshChannelData(c.Number), CancellationToken.None);
|
|
}
|
|
|
|
// Deliberately NOT Mapper.GetPlayoutsCount: this handler's query (see Handle) doesn't include
|
|
// MirrorSourceChannel, so the shared helper would read that navigation as null and return the
|
|
// same own-playouts-only count anyway — with a false air of Mirror-awareness. Harmless today
|
|
// because ChannelController discards this view model and re-projects through
|
|
// GetChannelByIdForApi, so this count never reaches the wire. If you ever return it directly,
|
|
// fix the QUERY first (add the MirrorSourceChannel ThenInclude) — swapping in the helper alone
|
|
// would report 0 playouts for a working mirror channel.
|
|
return ProjectToViewModel(c, c.Playouts?.Count ?? 0);
|
|
}
|
|
|
|
private static async Task<Validation<BaseError, Channel>> Validate(
|
|
TvContext dbContext,
|
|
UpdateChannel request,
|
|
Channel channel,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Validation<BaseError, Channel> channelValidation = (ValidateName(request),
|
|
await ValidateNumber(dbContext, request, cancellationToken),
|
|
await MirrorSourceMustBeValid(dbContext, request, channel, cancellationToken),
|
|
ValidateShowInEpg(request.IsEnabled, request.ShowInEpg),
|
|
ValidateLogo(request.Logo?.Path))
|
|
.Apply((_, _, _, _, _) => channel);
|
|
|
|
// combine the page-only Group rule plus the FK existence checks (FFmpeg profile / watermark /
|
|
// fallback filler) with the channel validation; splitting keeps tuple arity within
|
|
// LanguageExt's supported applicative range while still accumulating all errors
|
|
return (ValidateGroup(request.Group),
|
|
await FFmpegProfileMustExist(dbContext, request, cancellationToken),
|
|
await WatermarkMustExist(dbContext, request, cancellationToken),
|
|
await FillerPresetMustExist(dbContext, request, cancellationToken),
|
|
channelValidation)
|
|
.Apply((_, _, _, _, c) => c);
|
|
}
|
|
|
|
private static async Task<Validation<BaseError, int>> FFmpegProfileMustExist(
|
|
TvContext dbContext,
|
|
UpdateChannel request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
bool exists = await dbContext.FFmpegProfiles
|
|
.AnyAsync(p => p.Id == request.FFmpegProfileId, cancellationToken);
|
|
if (exists)
|
|
{
|
|
return request.FFmpegProfileId;
|
|
}
|
|
|
|
return BaseError.New($"FFmpegProfile {request.FFmpegProfileId} does not exist.");
|
|
}
|
|
|
|
private static async Task<Validation<BaseError, Option<int>>> WatermarkMustExist(
|
|
TvContext dbContext,
|
|
UpdateChannel request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (request.WatermarkId is null)
|
|
{
|
|
return Option<int>.None;
|
|
}
|
|
|
|
bool exists = await dbContext.ChannelWatermarks
|
|
.AnyAsync(w => w.Id == request.WatermarkId, cancellationToken);
|
|
if (exists)
|
|
{
|
|
return Optional(request.WatermarkId);
|
|
}
|
|
|
|
return BaseError.New($"Watermark {request.WatermarkId} does not exist.");
|
|
}
|
|
|
|
private static async Task<Validation<BaseError, Option<int>>> FillerPresetMustExist(
|
|
TvContext dbContext,
|
|
UpdateChannel request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (request.FallbackFillerId is null)
|
|
{
|
|
return Option<int>.None;
|
|
}
|
|
|
|
bool exists = await dbContext.FillerPresets
|
|
.Filter(fp => fp.FillerKind == FillerKind.Fallback)
|
|
.AnyAsync(w => w.Id == request.FallbackFillerId, cancellationToken);
|
|
if (exists)
|
|
{
|
|
return Optional(request.FallbackFillerId);
|
|
}
|
|
|
|
return BaseError.New($"Fallback filler {request.FallbackFillerId} does not exist.");
|
|
}
|
|
|
|
private static async Task<Validation<BaseError, Unit>> MirrorSourceMustBeValid(
|
|
TvContext dbContext,
|
|
UpdateChannel request,
|
|
Channel channel,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (request.PlayoutSource is not ChannelPlayoutSource.Mirror)
|
|
{
|
|
return Unit.Default;
|
|
}
|
|
|
|
// a channel with its own playout already built (Generated mode) cannot become a Mirror —
|
|
// Mirror channels relay another channel's playout and never build one of their own, so
|
|
// switching this transition on would strand the existing playout. This used to be
|
|
// silently coerced back to Generated (issue #401); reject the transition instead so the
|
|
// caller sees why the requested Mirror source was not applied. A round-trip that keeps
|
|
// PlayoutSource as Generated never reaches this check.
|
|
if (channel.Playouts.Count > 0)
|
|
{
|
|
return BaseError.New(
|
|
"Channel cannot switch to Mirror playout source while it has a playout; reset or delete the existing playout first.");
|
|
}
|
|
|
|
Option<Channel> maybeMirrorSource = await dbContext.Channels
|
|
.AsNoTracking()
|
|
.SelectOneAsync(
|
|
c => c.Id == request.MirrorSourceChannelId,
|
|
c => c.Id == request.MirrorSourceChannelId,
|
|
cancellationToken);
|
|
|
|
if (maybeMirrorSource.IsNone)
|
|
{
|
|
return BaseError.New("Mirror source channel does not exist.");
|
|
}
|
|
|
|
foreach (var mirrorSource in maybeMirrorSource)
|
|
{
|
|
if (mirrorSource.PlayoutSource is not ChannelPlayoutSource.Generated)
|
|
{
|
|
return BaseError.New(
|
|
$"Mirror source channel {mirrorSource.Name} must use generated playout source");
|
|
}
|
|
}
|
|
|
|
foreach (TimeSpan playoutOffset in Optional(request.PlayoutOffset))
|
|
{
|
|
if (playoutOffset < TimeSpan.FromHours(-12) || playoutOffset > TimeSpan.FromHours(12))
|
|
{
|
|
return BaseError.New("Playout offset must not be greater than 12 hours");
|
|
}
|
|
}
|
|
|
|
return Unit.Default;
|
|
}
|
|
|
|
private static Validation<BaseError, string> ValidateName(UpdateChannel updateChannel) =>
|
|
updateChannel.NotEmpty(c => c.Name)
|
|
.Bind(_ => updateChannel.NotLongerThan(50)(c => c.Name));
|
|
|
|
private static async Task<Validation<BaseError, string>> ValidateNumber(
|
|
TvContext dbContext,
|
|
UpdateChannel updateChannel,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
int matchId = await dbContext.Channels
|
|
.SelectOneAsync(c => c.Number, c => c.Number == updateChannel.Number, cancellationToken)
|
|
.Match(c => c.Id, () => updateChannel.ChannelId);
|
|
|
|
if (matchId == updateChannel.ChannelId)
|
|
{
|
|
if (Regex.IsMatch(updateChannel.Number, Channel.NumberValidator))
|
|
{
|
|
return updateChannel.Number;
|
|
}
|
|
|
|
return BaseError.New("Invalid channel number; two decimals are allowed for subchannels");
|
|
}
|
|
|
|
return BaseError.New("Channel number must be unique");
|
|
}
|
|
}
|