307 lines
13 KiB
C#
307 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Jellyfin.Plugin.SRFPlay.Api;
|
|
using Jellyfin.Plugin.SRFPlay.Api.Models;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace Jellyfin.Plugin.SRFPlay.Services;
|
|
|
|
/// <summary>
|
|
/// Service for refreshing content from SRF API.
|
|
/// </summary>
|
|
public class ContentRefreshService
|
|
{
|
|
private readonly ILogger<ContentRefreshService> _logger;
|
|
private readonly ILoggerFactory _loggerFactory;
|
|
private readonly MetadataCache _metadataCache;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="ContentRefreshService"/> class.
|
|
/// </summary>
|
|
/// <param name="loggerFactory">The logger factory.</param>
|
|
/// <param name="metadataCache">The metadata cache.</param>
|
|
public ContentRefreshService(
|
|
ILoggerFactory loggerFactory,
|
|
MetadataCache metadataCache)
|
|
{
|
|
_loggerFactory = loggerFactory;
|
|
_logger = loggerFactory.CreateLogger<ContentRefreshService>();
|
|
_metadataCache = metadataCache;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Refreshes latest content from SRF API using Play v3.
|
|
/// </summary>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>List of URNs for new content.</returns>
|
|
public async Task<List<string>> RefreshLatestContentAsync(CancellationToken cancellationToken)
|
|
{
|
|
var urns = new List<string>();
|
|
|
|
try
|
|
{
|
|
var config = Plugin.Instance?.Configuration;
|
|
if (config == null || !config.EnableLatestContent)
|
|
{
|
|
_logger.LogDebug("Latest content refresh is disabled");
|
|
return urns;
|
|
}
|
|
|
|
_logger.LogInformation("Refreshing latest content for business unit: {BusinessUnit}", config.BusinessUnit);
|
|
|
|
using var apiClient = new SRFApiClient(_loggerFactory);
|
|
var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
|
|
|
|
// Get all shows from Play v3 API
|
|
var shows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
|
|
|
|
if (shows == null || shows.Count == 0)
|
|
{
|
|
_logger.LogWarning("No shows found for business unit: {BusinessUnit}", config.BusinessUnit);
|
|
return urns;
|
|
}
|
|
|
|
_logger.LogInformation("Found {Count} shows, fetching latest episodes from each", shows.Count);
|
|
|
|
// Get latest episodes from each show (limit to 20 shows to avoid overwhelming)
|
|
var showsToFetch = shows.Where(s => s.NumberOfEpisodes > 0)
|
|
.OrderByDescending(s => s.NumberOfEpisodes)
|
|
.Take(20)
|
|
.ToList();
|
|
|
|
foreach (var show in showsToFetch)
|
|
{
|
|
if (show.Id == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
|
|
if (videos != null && videos.Count > 0)
|
|
{
|
|
_logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos", show.Title, show.Id, videos.Count);
|
|
|
|
// Filter to videos that are actually published (validFrom in the past)
|
|
var now = DateTime.UtcNow;
|
|
var publishedVideos = videos.Where(v =>
|
|
v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now).ToList();
|
|
|
|
_logger.LogDebug("Show {Show}: {PublishedCount} published out of {TotalCount} videos", show.Title, publishedVideos.Count, videos.Count);
|
|
|
|
if (publishedVideos.Count > 0)
|
|
{
|
|
// Take only the most recent published video from each show
|
|
var latestVideo = publishedVideos.OrderByDescending(v => v.Date).FirstOrDefault();
|
|
if (latestVideo?.Urn != null)
|
|
{
|
|
urns.Add(latestVideo.Urn);
|
|
_logger.LogInformation(
|
|
"Added latest video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
|
|
show.Title,
|
|
latestVideo.Title,
|
|
latestVideo.Urn,
|
|
latestVideo.Date,
|
|
latestVideo.ValidFrom,
|
|
latestVideo.ValidTo);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogWarning("Show {Show}: Latest video has null URN", show.Title);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_logger.LogDebug("Show {Show} has no published videos yet", show.Title);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API", show.Title, show.Id);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Error fetching videos for show {ShowId}", show.Id);
|
|
}
|
|
|
|
// Respect cancellation
|
|
if (cancellationToken.IsCancellationRequested)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
_logger.LogInformation("Refreshed {Count} latest content items from {ShowCount} shows", urns.Count, showsToFetch.Count);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error refreshing latest content");
|
|
}
|
|
|
|
return urns;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Refreshes trending content from SRF API using Play v3.
|
|
/// Gets videos from shows with the most episodes.
|
|
/// </summary>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>List of URNs for trending content.</returns>
|
|
public async Task<List<string>> RefreshTrendingContentAsync(CancellationToken cancellationToken)
|
|
{
|
|
var urns = new List<string>();
|
|
|
|
try
|
|
{
|
|
var config = Plugin.Instance?.Configuration;
|
|
if (config == null || !config.EnableTrendingContent)
|
|
{
|
|
_logger.LogDebug("Trending content refresh is disabled");
|
|
return urns;
|
|
}
|
|
|
|
_logger.LogInformation("Refreshing trending content for business unit: {BusinessUnit}", config.BusinessUnit);
|
|
|
|
using var apiClient = new SRFApiClient(_loggerFactory);
|
|
var businessUnit = config.BusinessUnit.ToString().ToLowerInvariant();
|
|
|
|
// Get all shows from Play v3 API
|
|
var shows = await apiClient.GetAllShowsAsync(businessUnit, cancellationToken).ConfigureAwait(false);
|
|
|
|
if (shows == null || shows.Count == 0)
|
|
{
|
|
_logger.LogWarning("No shows found for business unit: {BusinessUnit}", config.BusinessUnit);
|
|
return urns;
|
|
}
|
|
|
|
_logger.LogInformation("Found {Count} shows, fetching popular content", shows.Count);
|
|
|
|
// Get videos from popular shows (those with many episodes)
|
|
var popularShows = shows.Where(s => s.NumberOfEpisodes > 10)
|
|
.OrderByDescending(s => s.NumberOfEpisodes)
|
|
.Take(15)
|
|
.ToList();
|
|
|
|
foreach (var show in popularShows)
|
|
{
|
|
if (show.Id == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
try
|
|
{
|
|
var videos = await apiClient.GetVideosForShowAsync(businessUnit, show.Id, cancellationToken).ConfigureAwait(false);
|
|
if (videos != null && videos.Count > 0)
|
|
{
|
|
_logger.LogDebug("Show {Show} ({ShowId}): Found {Count} videos for trending", show.Title, show.Id, videos.Count);
|
|
|
|
// Filter to videos that are actually published (validFrom in the past)
|
|
var now = DateTime.UtcNow;
|
|
var publishedVideos = videos.Where(v =>
|
|
v.ValidFrom == null || v.ValidFrom.Value.ToUniversalTime() <= now).ToList();
|
|
|
|
_logger.LogDebug("Show {Show}: {PublishedCount} published out of {TotalCount} videos for trending", show.Title, publishedVideos.Count, videos.Count);
|
|
|
|
if (publishedVideos.Count > 0)
|
|
{
|
|
// Take 2 recent published videos from each popular show
|
|
var recentVideos = publishedVideos.OrderByDescending(v => v.Date).Take(2);
|
|
foreach (var video in recentVideos)
|
|
{
|
|
if (video.Urn != null)
|
|
{
|
|
urns.Add(video.Urn);
|
|
_logger.LogInformation(
|
|
"Added trending video from show {Show}: {Title} (URN: {Urn}, Date: {Date}, ValidFrom: {ValidFrom}, ValidTo: {ValidTo})",
|
|
show.Title,
|
|
video.Title,
|
|
video.Urn,
|
|
video.Date,
|
|
video.ValidFrom,
|
|
video.ValidTo);
|
|
}
|
|
else
|
|
{
|
|
_logger.LogWarning("Show {Show}: Trending video has null URN - {Title}", show.Title, video.Title);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_logger.LogDebug("Show {Show} ({ShowId}): No videos returned from API for trending", show.Title, show.Id);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Error fetching videos for show {ShowId}", show.Id);
|
|
}
|
|
|
|
// Respect cancellation
|
|
if (cancellationToken.IsCancellationRequested)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
_logger.LogInformation("Refreshed {Count} trending content items from {ShowCount} shows", urns.Count, popularShows.Count);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error refreshing trending content");
|
|
}
|
|
|
|
return urns;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Refreshes all content (latest and trending).
|
|
/// </summary>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>Tuple with counts of latest and trending items.</returns>
|
|
public async Task<(int LatestCount, int TrendingCount)> RefreshAllContentAsync(CancellationToken cancellationToken)
|
|
{
|
|
_logger.LogInformation("Starting full content refresh");
|
|
|
|
var latestUrns = await RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
|
|
var trendingUrns = await RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
var latestCount = latestUrns.Count;
|
|
var trendingCount = trendingUrns.Count;
|
|
|
|
_logger.LogInformation(
|
|
"Content refresh completed. Latest: {LatestCount}, Trending: {TrendingCount}",
|
|
latestCount,
|
|
trendingCount);
|
|
|
|
return (latestCount, trendingCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets content recommendations (combines latest and trending).
|
|
/// </summary>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
/// <returns>List of recommended URNs.</returns>
|
|
public async Task<List<string>> GetRecommendedContentAsync(CancellationToken cancellationToken)
|
|
{
|
|
var recommendations = new HashSet<string>();
|
|
|
|
var latestUrns = await RefreshLatestContentAsync(cancellationToken).ConfigureAwait(false);
|
|
var trendingUrns = await RefreshTrendingContentAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
foreach (var urn in latestUrns.Concat(trendingUrns))
|
|
{
|
|
recommendations.Add(urn);
|
|
}
|
|
|
|
_logger.LogInformation("Generated {Count} content recommendations", recommendations.Count);
|
|
return recommendations.ToList();
|
|
}
|
|
}
|