575 lines
24 KiB
C#
575 lines
24 KiB
C#
using System.Threading.Channels;
|
|
using EFCore.BulkExtensions;
|
|
using ErsatzTV.Application.Channels;
|
|
using ErsatzTV.Application.Subtitles;
|
|
using ErsatzTV.Core;
|
|
using ErsatzTV.Core.Domain;
|
|
using ErsatzTV.Core.Domain.Scheduling;
|
|
using ErsatzTV.Core.Interfaces.FFmpeg;
|
|
using ErsatzTV.Core.Interfaces.Locking;
|
|
using ErsatzTV.Core.Interfaces.Scheduling;
|
|
using ErsatzTV.Core.Scheduling;
|
|
using ErsatzTV.Infrastructure.Data;
|
|
using ErsatzTV.Infrastructure.Extensions;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Logging;
|
|
using Channel = ErsatzTV.Core.Domain.Channel;
|
|
|
|
namespace ErsatzTV.Application.Playouts;
|
|
|
|
public class BuildPlayoutHandler : IRequestHandler<BuildPlayout, Either<BaseError, Unit>>
|
|
{
|
|
private readonly IBlockPlayoutBuilder _blockPlayoutBuilder;
|
|
private readonly IBlockPlayoutFillerBuilder _blockPlayoutFillerBuilder;
|
|
private readonly IDbContextFactory<TvContext> _dbContextFactory;
|
|
private readonly IEntityLocker _entityLocker;
|
|
private readonly IExternalJsonPlayoutBuilder _externalJsonPlayoutBuilder;
|
|
private readonly IFFmpegSegmenterService _ffmpegSegmenterService;
|
|
private readonly IPlayoutBuilder _playoutBuilder;
|
|
private readonly IPlayoutTimeShifter _playoutTimeShifter;
|
|
private readonly ChannelWriter<IBackgroundServiceRequest> _workerChannel;
|
|
private readonly ILogger<BuildPlayoutHandler> _logger;
|
|
private readonly ISequentialPlayoutBuilder _sequentialPlayoutBuilder;
|
|
private readonly IScriptedPlayoutBuilder _scriptedPlayoutBuilder;
|
|
|
|
public BuildPlayoutHandler(
|
|
IDbContextFactory<TvContext> dbContextFactory,
|
|
IPlayoutBuilder playoutBuilder,
|
|
IBlockPlayoutBuilder blockPlayoutBuilder,
|
|
IBlockPlayoutFillerBuilder blockPlayoutFillerBuilder,
|
|
ISequentialPlayoutBuilder sequentialPlayoutBuilder,
|
|
IScriptedPlayoutBuilder scriptedPlayoutBuilder,
|
|
IExternalJsonPlayoutBuilder externalJsonPlayoutBuilder,
|
|
IFFmpegSegmenterService ffmpegSegmenterService,
|
|
IEntityLocker entityLocker,
|
|
IPlayoutTimeShifter playoutTimeShifter,
|
|
ChannelWriter<IBackgroundServiceRequest> workerChannel,
|
|
ILogger<BuildPlayoutHandler> logger)
|
|
{
|
|
_dbContextFactory = dbContextFactory;
|
|
_playoutBuilder = playoutBuilder;
|
|
_blockPlayoutBuilder = blockPlayoutBuilder;
|
|
_blockPlayoutFillerBuilder = blockPlayoutFillerBuilder;
|
|
_sequentialPlayoutBuilder = sequentialPlayoutBuilder;
|
|
_scriptedPlayoutBuilder = scriptedPlayoutBuilder;
|
|
_externalJsonPlayoutBuilder = externalJsonPlayoutBuilder;
|
|
_ffmpegSegmenterService = ffmpegSegmenterService;
|
|
_entityLocker = entityLocker;
|
|
_playoutTimeShifter = playoutTimeShifter;
|
|
_workerChannel = workerChannel;
|
|
_logger = logger;
|
|
}
|
|
|
|
public async Task<Either<BaseError, Unit>> Handle(BuildPlayout request, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
await _entityLocker.LockPlayout(request.PlayoutId);
|
|
if (request.Mode is not PlayoutBuildMode.Reset)
|
|
{
|
|
// this needs to happen before we load the playout in this handler because it modifies items, etc
|
|
await _playoutTimeShifter.TimeShift(request.PlayoutId, DateTimeOffset.Now, false, cancellationToken);
|
|
}
|
|
|
|
Either<BaseError, PlayoutBuildResult> result;
|
|
|
|
{
|
|
await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
|
|
Validation<BaseError, Playout> validation = await Validate(dbContext, request, cancellationToken);
|
|
result = await validation.Match(
|
|
playout => ApplyUpdateRequest(dbContext, request, playout, cancellationToken),
|
|
error => Task.FromResult<Either<BaseError, PlayoutBuildResult>>(error.Join()));
|
|
}
|
|
|
|
// after dbcontext is closed
|
|
foreach (PlayoutBuildResult playoutBuildResult in result.RightToSeq())
|
|
{
|
|
foreach (DateTimeOffset timeShiftTo in playoutBuildResult.TimeShiftTo)
|
|
{
|
|
await _playoutTimeShifter.TimeShift(request.PlayoutId, timeShiftTo, false, cancellationToken);
|
|
}
|
|
|
|
if (playoutBuildResult.Warnings.TailFillerTooLong > 0)
|
|
{
|
|
_logger.LogDebug(
|
|
"Playout {PlayoutId} skipped {Count} tail filler items that were too long to fit",
|
|
request.PlayoutId,
|
|
playoutBuildResult.Warnings.TailFillerTooLong);
|
|
}
|
|
|
|
if (playoutBuildResult.Warnings.MidRollContentWithoutChapters > 0)
|
|
{
|
|
_logger.LogDebug(
|
|
"Playout {PlayoutId} converted mid-roll to post-roll for {Count} items that have no chapter markers",
|
|
request.PlayoutId,
|
|
playoutBuildResult.Warnings.MidRollContentWithoutChapters);
|
|
}
|
|
|
|
if (playoutBuildResult.Warnings.DurationFillerSkipped > 0)
|
|
{
|
|
_logger.LogDebug(
|
|
"Playout {PlayoutId} skipped {Count} filler items to try to fit in a small remaining duration",
|
|
request.PlayoutId,
|
|
playoutBuildResult.Warnings.DurationFillerSkipped);
|
|
}
|
|
|
|
if (playoutBuildResult.Warnings.BlockItemSkippedEmptyCollection > 0)
|
|
{
|
|
_logger.LogDebug(
|
|
"Playout {PlayoutId} skipped {Count} block items due to empty collections",
|
|
request.PlayoutId,
|
|
playoutBuildResult.Warnings.BlockItemSkippedEmptyCollection);
|
|
}
|
|
}
|
|
|
|
return result.Map(_ => Unit.Default);
|
|
}
|
|
finally
|
|
{
|
|
await _entityLocker.UnlockPlayout(request.PlayoutId);
|
|
}
|
|
}
|
|
|
|
private async Task<Either<BaseError, PlayoutBuildResult>> ApplyUpdateRequest(
|
|
TvContext dbContext,
|
|
BuildPlayout request,
|
|
Playout playout,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var channelName = "[unknown]";
|
|
|
|
await dbContext.PlayoutBuildStatus
|
|
.Where(pbs => pbs.PlayoutId == playout.Id)
|
|
.ExecuteDeleteAsync(cancellationToken);
|
|
|
|
var newBuildStatus = new PlayoutBuildStatus
|
|
{
|
|
PlayoutId = playout.Id,
|
|
LastBuild = DateTimeOffset.Now
|
|
};
|
|
|
|
try
|
|
{
|
|
PlayoutReferenceData referenceData = await GetReferenceData(
|
|
dbContext,
|
|
playout.Id,
|
|
playout.ScheduleKind);
|
|
string channelNumber = referenceData.Channel.Number;
|
|
channelName = referenceData.Channel.Name;
|
|
Either<BaseError, PlayoutBuildResult> buildResult = BaseError.New("Unsupported schedule kind");
|
|
|
|
switch (playout.ScheduleKind)
|
|
{
|
|
case PlayoutScheduleKind.Block:
|
|
buildResult = await _blockPlayoutBuilder.Build(
|
|
request.Start,
|
|
playout,
|
|
referenceData,
|
|
request.Mode,
|
|
cancellationToken);
|
|
|
|
foreach (var result in buildResult.RightToSeq())
|
|
{
|
|
buildResult = await _blockPlayoutFillerBuilder.Build(
|
|
playout,
|
|
referenceData,
|
|
result,
|
|
request.Mode,
|
|
cancellationToken);
|
|
}
|
|
|
|
break;
|
|
case PlayoutScheduleKind.Sequential:
|
|
buildResult = await _sequentialPlayoutBuilder.Build(
|
|
request.Start,
|
|
playout,
|
|
referenceData,
|
|
request.Mode,
|
|
cancellationToken);
|
|
break;
|
|
case PlayoutScheduleKind.Scripted:
|
|
buildResult = await _scriptedPlayoutBuilder.Build(
|
|
request.Start,
|
|
playout,
|
|
referenceData,
|
|
request.Mode,
|
|
cancellationToken);
|
|
break;
|
|
case PlayoutScheduleKind.ExternalJson:
|
|
await _externalJsonPlayoutBuilder.Build(playout, request.Mode, cancellationToken);
|
|
break;
|
|
case PlayoutScheduleKind.None:
|
|
case PlayoutScheduleKind.Classic:
|
|
default:
|
|
buildResult = await _playoutBuilder.Build(
|
|
request.Start,
|
|
playout,
|
|
referenceData,
|
|
request.Mode,
|
|
cancellationToken);
|
|
break;
|
|
}
|
|
|
|
return await buildResult.MatchAsync<Either<BaseError, PlayoutBuildResult>>(
|
|
async result =>
|
|
{
|
|
var changeCount = 0;
|
|
|
|
if (result.RerunHistoryToRemove.Count > 0)
|
|
{
|
|
changeCount += await dbContext.RerunHistory
|
|
.Where(rh => result.RerunHistoryToRemove.Contains(rh.Id))
|
|
.ExecuteDeleteAsync(cancellationToken);
|
|
}
|
|
|
|
if (result.AddedRerunHistory.Count > 0)
|
|
{
|
|
changeCount += 1;
|
|
await dbContext.BulkInsertAsync(result.AddedRerunHistory, cancellationToken: cancellationToken);
|
|
}
|
|
|
|
if (result.ClearItems)
|
|
{
|
|
changeCount += await dbContext.PlayoutItems
|
|
.Where(pi => pi.PlayoutId == playout.Id)
|
|
.ExecuteDeleteAsync(cancellationToken);
|
|
}
|
|
|
|
foreach (DateTimeOffset removeBefore in result.RemoveBefore)
|
|
{
|
|
changeCount += await dbContext.PlayoutItems
|
|
.Where(pi => pi.PlayoutId == playout.Id)
|
|
.Where(pi => pi.Finish < removeBefore.UtcDateTime - referenceData.MaxPlayoutOffset)
|
|
.ExecuteDeleteAsync(cancellationToken);
|
|
}
|
|
|
|
foreach (DateTimeOffset removeAfter in result.RemoveAfter)
|
|
{
|
|
changeCount += await dbContext.PlayoutItems
|
|
.Where(pi => pi.PlayoutId == playout.Id)
|
|
.Where(pi => pi.Start >= removeAfter.UtcDateTime)
|
|
.ExecuteDeleteAsync(cancellationToken);
|
|
}
|
|
|
|
if (result.ItemsToRemove.Count > 0)
|
|
{
|
|
changeCount += await dbContext.PlayoutItems
|
|
.Where(pi => result.ItemsToRemove.Contains(pi.Id))
|
|
.ExecuteDeleteAsync(cancellationToken);
|
|
}
|
|
|
|
if (result.AddedItems.Count > 0)
|
|
{
|
|
changeCount += 1;
|
|
bool anyWatermarks = result.AddedItems.Any(i =>
|
|
i.PlayoutItemWatermarks is not null && i.PlayoutItemWatermarks.Count > 0);
|
|
bool anyGraphicsElements = result.AddedItems.Any(i =>
|
|
i.PlayoutItemGraphicsElements is not null && i.PlayoutItemGraphicsElements.Count > 0);
|
|
if (anyWatermarks || anyGraphicsElements)
|
|
{
|
|
// need to use slow ef core to also insert watermarks and graphics elements properly
|
|
await dbContext.AddRangeAsync(result.AddedItems, cancellationToken);
|
|
}
|
|
else
|
|
{
|
|
// no watermarks or graphics, bulk insert is ok
|
|
await dbContext.BulkInsertAsync(result.AddedItems, cancellationToken: cancellationToken);
|
|
}
|
|
}
|
|
|
|
if (result.HistoryToRemove.Count > 0)
|
|
{
|
|
changeCount += await dbContext.PlayoutHistory
|
|
.Where(ph => result.HistoryToRemove.Contains(ph.Id))
|
|
.ExecuteDeleteAsync(cancellationToken);
|
|
}
|
|
|
|
if (result.AddedHistory.Count > 0)
|
|
{
|
|
changeCount += 1;
|
|
await dbContext.BulkInsertAsync(result.AddedHistory, cancellationToken: cancellationToken);
|
|
}
|
|
|
|
// let any active segmenter processes know that the playout has been modified
|
|
// and therefore the segmenter may need to seek into the next item instead of
|
|
// starting at the beginning (if already working ahead)
|
|
changeCount += await dbContext.SaveChangesAsync(cancellationToken);
|
|
bool hasChanges = changeCount > 0 || referenceData.Channel.PlayoutMode is ChannelPlayoutMode.OnDemand;
|
|
|
|
if (request.Mode != PlayoutBuildMode.Continue && hasChanges)
|
|
{
|
|
_ffmpegSegmenterService.PlayoutUpdated(referenceData.Channel.Number);
|
|
}
|
|
|
|
await _workerChannel.WriteAsync(
|
|
new CheckForOverlappingPlayoutItems(request.PlayoutId),
|
|
cancellationToken);
|
|
|
|
await _workerChannel.WriteAsync(new InsertPlayoutGaps(request.PlayoutId), cancellationToken);
|
|
|
|
string fileName = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{channelNumber}.xml");
|
|
if (hasChanges || !File.Exists(fileName) ||
|
|
playout.ScheduleKind is PlayoutScheduleKind.ExternalJson)
|
|
{
|
|
await _workerChannel.WriteAsync(new RefreshChannelData(channelNumber), cancellationToken);
|
|
|
|
// refresh guide data for all mirror channels, too
|
|
List<string> maybeMirrors = await dbContext.Channels
|
|
.AsNoTracking()
|
|
.Filter(c => c.MirrorSourceChannelId == referenceData.Channel.Id)
|
|
.Map(c => c.Number)
|
|
.ToListAsync(cancellationToken);
|
|
foreach (string mirror in maybeMirrors)
|
|
{
|
|
await _workerChannel.WriteAsync(new RefreshChannelData(mirror), cancellationToken);
|
|
}
|
|
}
|
|
|
|
await _workerChannel.WriteAsync(new ExtractEmbeddedSubtitles(playout.Id), cancellationToken);
|
|
|
|
newBuildStatus.Success = true;
|
|
|
|
return result;
|
|
},
|
|
error =>
|
|
{
|
|
newBuildStatus.Success = false;
|
|
newBuildStatus.Message = error.Value;
|
|
|
|
return error;
|
|
});
|
|
}
|
|
catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
|
|
{
|
|
newBuildStatus.Success = false;
|
|
newBuildStatus.Message = $"Timeout building playout for channel {channelName}";
|
|
|
|
return BaseError.New(
|
|
$"Timeout building playout for channel {channelName}; this may be a bug!");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DebugBreak.Break();
|
|
|
|
newBuildStatus.Success = false;
|
|
newBuildStatus.Message = $"Unexpected error building playout for channel {channelName}: {ex}";
|
|
|
|
return BaseError.New(
|
|
$"Unexpected error building playout for channel {channelName}: {ex.Message}");
|
|
}
|
|
finally
|
|
{
|
|
try
|
|
{
|
|
await dbContext.PlayoutBuildStatus.AddAsync(newBuildStatus, CancellationToken.None);
|
|
await dbContext.SaveChangesAsync(CancellationToken.None);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// do nothing
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Task<Validation<BaseError, Playout>> Validate(
|
|
TvContext dbContext,
|
|
BuildPlayout request,
|
|
CancellationToken cancellationToken) =>
|
|
PlayoutMustExist(dbContext, request, cancellationToken).BindT(DiscardAttemptsMustBeValid);
|
|
|
|
private static Validation<BaseError, Playout> DiscardAttemptsMustBeValid(Playout playout)
|
|
{
|
|
foreach (ProgramScheduleItemDuration item in
|
|
playout.ProgramSchedule?.Items.OfType<ProgramScheduleItemDuration>() ?? [])
|
|
{
|
|
item.DiscardToFillAttempts = item.PlaybackOrder switch
|
|
{
|
|
PlaybackOrder.Random or PlaybackOrder.Shuffle => item.DiscardToFillAttempts,
|
|
_ => 0
|
|
};
|
|
}
|
|
|
|
return playout;
|
|
}
|
|
|
|
private static async Task<Validation<BaseError, Playout>> PlayoutMustExist(
|
|
TvContext dbContext,
|
|
BuildPlayout buildPlayout,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Option<Playout> maybePlayout = await dbContext.Playouts
|
|
.Include(p => p.Anchor)
|
|
.SelectOneAsync(p => p.Id, p => p.Id == buildPlayout.PlayoutId, cancellationToken);
|
|
|
|
foreach (Playout playout in maybePlayout)
|
|
{
|
|
switch (playout.ScheduleKind)
|
|
{
|
|
case PlayoutScheduleKind.Classic:
|
|
await dbContext.Entry(playout)
|
|
.Collection(p => p.FillGroupIndices)
|
|
.LoadAsync(cancellationToken);
|
|
|
|
foreach (PlayoutScheduleItemFillGroupIndex fillGroupIndex in playout.FillGroupIndices)
|
|
{
|
|
await dbContext.Entry(fillGroupIndex)
|
|
.Reference(fgi => fgi.EnumeratorState)
|
|
.LoadAsync(cancellationToken);
|
|
}
|
|
|
|
await dbContext.Entry(playout)
|
|
.Collection(p => p.ProgramScheduleAnchors)
|
|
.LoadAsync(cancellationToken);
|
|
|
|
foreach (PlayoutProgramScheduleAnchor anchor in playout.ProgramScheduleAnchors)
|
|
{
|
|
await dbContext.Entry(anchor)
|
|
.Reference(a => a.EnumeratorState)
|
|
.LoadAsync(cancellationToken);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return maybePlayout.ToValidation<BaseError>("Playout does not exist.");
|
|
}
|
|
|
|
private static async Task<PlayoutReferenceData> GetReferenceData(
|
|
TvContext dbContext,
|
|
int playoutId,
|
|
PlayoutScheduleKind scheduleKind)
|
|
{
|
|
Channel channel = await dbContext.Channels
|
|
.AsNoTracking()
|
|
.Where(c => c.Playouts.Any(p => p.Id == playoutId))
|
|
.FirstOrDefaultAsync();
|
|
|
|
TimeSpan maxPlayoutOffset = TimeSpan.Zero;
|
|
List<Channel> mirrorChannels = await dbContext.Channels
|
|
.AsNoTracking()
|
|
.Where(c => c.MirrorSourceChannelId == channel.Id)
|
|
.ToListAsync();
|
|
foreach (var mirrorChannel in mirrorChannels)
|
|
{
|
|
var offset = mirrorChannel.PlayoutOffset ?? TimeSpan.Zero;
|
|
if (offset > maxPlayoutOffset)
|
|
{
|
|
maxPlayoutOffset = offset;
|
|
}
|
|
}
|
|
|
|
Option<Deco> deco = Option<Deco>.None;
|
|
List<PlayoutItem> existingItems = [];
|
|
List<PlayoutTemplate> playoutTemplates = [];
|
|
|
|
if (scheduleKind is PlayoutScheduleKind.Block)
|
|
{
|
|
deco = await dbContext.Decos
|
|
.AsNoTracking()
|
|
.Include(d => d.BreakContent)
|
|
.Where(d => d.Playouts.Any(p => p.Id == playoutId))
|
|
.FirstOrDefaultAsync()
|
|
.Map(Optional);
|
|
|
|
existingItems = await dbContext.PlayoutItems
|
|
.AsNoTracking()
|
|
.Where(pi => pi.PlayoutId == playoutId)
|
|
.ToListAsync();
|
|
|
|
playoutTemplates = await dbContext.PlayoutTemplates
|
|
.AsNoTracking()
|
|
.Where(pt => pt.PlayoutId == playoutId)
|
|
.Include(t => t.Template)
|
|
.ThenInclude(t => t.Items)
|
|
.ThenInclude(i => i.Block)
|
|
.ThenInclude(b => b.Items)
|
|
.ThenInclude(i => i.BlockItemWatermarks)
|
|
.Include(t => t.Template)
|
|
.ThenInclude(t => t.Items)
|
|
.ThenInclude(i => i.Block)
|
|
.ThenInclude(b => b.Items)
|
|
.ThenInclude(i => i.BlockItemGraphicsElements)
|
|
.Include(t => t.DecoTemplate)
|
|
.ThenInclude(t => t.Items)
|
|
.ThenInclude(i => i.Deco)
|
|
.ThenInclude(d => d.BreakContent)
|
|
.ToListAsync();
|
|
}
|
|
|
|
ProgramSchedule programSchedule = await dbContext.ProgramSchedules
|
|
.AsNoTracking()
|
|
.Where(ps => ps.Playouts.Any(p => p.Id == playoutId))
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.ProgramScheduleItemWatermarks)
|
|
.ThenInclude(psi => psi.Watermark)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.ProgramScheduleItemGraphicsElements)
|
|
.ThenInclude(psi => psi.GraphicsElement)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.Collection)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.MediaItem)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.PreRollFiller)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.MidRollFiller)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.PostRollFiller)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.TailFiller)
|
|
.Include(ps => ps.Items)
|
|
.ThenInclude(psi => psi.FallbackFiller)
|
|
.FirstOrDefaultAsync();
|
|
|
|
List<ProgramScheduleAlternate> programScheduleAlternates = await dbContext.ProgramScheduleAlternates
|
|
.AsNoTracking()
|
|
.Where(pt => pt.PlayoutId == playoutId)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.ProgramScheduleItemWatermarks)
|
|
.ThenInclude(psi => psi.Watermark)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.ProgramScheduleItemGraphicsElements)
|
|
.ThenInclude(psi => psi.GraphicsElement)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.Collection)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.MediaItem)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.PreRollFiller)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.MidRollFiller)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.PostRollFiller)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.TailFiller)
|
|
.Include(a => a.ProgramSchedule)
|
|
.ThenInclude(ps => ps.Items)
|
|
.ThenInclude(psi => psi.FallbackFiller)
|
|
.ToListAsync();
|
|
|
|
List<PlayoutHistory> playoutHistory = await dbContext.PlayoutHistory
|
|
.AsNoTracking()
|
|
.Where(h => h.PlayoutId == playoutId)
|
|
.ToListAsync();
|
|
|
|
return new PlayoutReferenceData(
|
|
channel,
|
|
deco,
|
|
existingItems,
|
|
playoutTemplates,
|
|
programSchedule,
|
|
programScheduleAlternates,
|
|
playoutHistory,
|
|
maxPlayoutOffset);
|
|
}
|
|
}
|