346 lines
14 KiB
C#
346 lines
14 KiB
C#
using System.Net;
|
|
using System.Text.RegularExpressions;
|
|
using AnimeAnnouncer.Cache;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.AspNetCore.Mvc.RazorPages;
|
|
|
|
namespace AnimeAnnouncer.Web.Pages;
|
|
|
|
public class IndexModel : PageModel
|
|
{
|
|
private readonly ILogger<IndexModel> _logger;
|
|
private readonly TMDBCache? _tmdbCache;
|
|
|
|
public List<AiringShowViewModel> AiringShows { get; set; } = new();
|
|
|
|
public string? ErrorMessage { get; set; }
|
|
|
|
public IndexModel(ILogger<IndexModel> logger, IServiceProvider serviceProvider)
|
|
{
|
|
_logger = logger;
|
|
_tmdbCache = serviceProvider.GetService<TMDBCache>();
|
|
}
|
|
|
|
public async Task OnGetAsync()
|
|
{
|
|
if (_tmdbCache == null)
|
|
{
|
|
ErrorMessage = "Redis cache connection is not configured or unavailable.";
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
List<AiringSoonItem>? airingList = await _tmdbCache.GetAiringList();
|
|
|
|
if (airingList == null || airingList.Count == 0)
|
|
{
|
|
AiringShows = new List<AiringShowViewModel>();
|
|
return;
|
|
}
|
|
|
|
var viewModels = new List<AiringShowViewModel>();
|
|
|
|
foreach (var airingItem in airingList)
|
|
{
|
|
TMDBCacheItem? cacheItem = null;
|
|
try
|
|
{
|
|
cacheItem = await _tmdbCache.GetCacheItem<TMDBCacheItem>($"ShowCache-{airingItem.Title}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to retrieve cache item for title: {Title}", airingItem.Title);
|
|
}
|
|
|
|
// The announcer stores Anilist details under a parallel key using the same
|
|
// title, so the two caches line up one-to-one when Anilist was consulted.
|
|
AnilistCacheItem? anilistItem = null;
|
|
try
|
|
{
|
|
anilistItem = await _tmdbCache.GetCacheItem<AnilistCacheItem>($"AnilistCache-{airingItem.Title}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "Failed to retrieve Anilist cache item for title: {Title}", airingItem.Title);
|
|
}
|
|
|
|
// With no details from either source there is nothing worth displaying.
|
|
if (cacheItem == null && anilistItem == null)
|
|
continue;
|
|
|
|
viewModels.Add(new AiringShowViewModel
|
|
{
|
|
AiringSoon = airingItem,
|
|
CachedDetails = cacheItem,
|
|
AnilistDetails = anilistItem
|
|
});
|
|
}
|
|
|
|
// Exclude placeholder/sentinel last-air-dates (e.g. DateTime.MaxValue == 12/31/9999,
|
|
// used by the announcer when an exact air date is unknown), then sort descending
|
|
// by LastAirDate (nulls last).
|
|
var displayable = viewModels.Where(x =>
|
|
{
|
|
var date = x.EffectiveLastAirDate;
|
|
// Keep items with a real, displayable date; drop the MaxValue sentinel.
|
|
return !date.HasValue || date.Value < DateTime.MaxValue.AddMonths(-1);
|
|
}).ToList();
|
|
|
|
AiringShows = displayable
|
|
.Where(x => x.EffectiveLastAirDate.HasValue && x.EffectiveLastAirDate.Value.Date >= DateTime.Now.Date)
|
|
.OrderBy(x => x.EffectiveLastAirDate)
|
|
.ThenBy(x => x.Title)
|
|
.ToList();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error loading airing soon list");
|
|
ErrorMessage = $"Unable to load airing soon list: {ex.Message}";
|
|
}
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostDownloadAsync(int showId)
|
|
{
|
|
if (_tmdbCache == null)
|
|
return StatusCode(StatusCodes.Status503ServiceUnavailable);
|
|
|
|
try
|
|
{
|
|
if (!await _tmdbCache.SetDownload(showId, true))
|
|
_logger.LogWarning("Download requested for show {ShowID}, which is not in the airing list", showId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Failed to flag show {ShowID} for download", showId);
|
|
}
|
|
|
|
// Post/redirect/get, landing back on the row that was clicked.
|
|
return RedirectToPage(null, null, null, $"show-{showId}");
|
|
}
|
|
|
|
public class ShowImage
|
|
{
|
|
public required string Url { get; set; }
|
|
public required string Label { get; set; }
|
|
public required string Source { get; set; }
|
|
}
|
|
|
|
public class AiringShowViewModel
|
|
{
|
|
private static readonly Regex HtmlTagPattern = new("<[^>]+>", RegexOptions.Compiled);
|
|
|
|
public required AiringSoonItem AiringSoon { get; set; }
|
|
public TMDBCacheItem? CachedDetails { get; set; }
|
|
public AnilistCacheItem? AnilistDetails { get; set; }
|
|
|
|
public string Title => AiringSoon.Title;
|
|
public int ShowID => AiringSoon.ShowID;
|
|
public bool Download => AiringSoon.Download;
|
|
public DateTime? EffectiveLastAirDate => AiringSoon.LastAirDate ?? CachedDetails?.LastAirDate;
|
|
public int LatestEpisodeNumber => AiringSoon.LatestEpisodeNumber > 0
|
|
? AiringSoon.LatestEpisodeNumber
|
|
: (CachedDetails?.LatestEpisodeNumber ?? 0);
|
|
public int? LastEpisodeNumber => CachedDetails?.LastEpisodeNumber;
|
|
public int? LatestSeasonNumber => CachedDetails?.LatestSeasonNumber;
|
|
public int? LatestOrdinalEpisodeNumber => CachedDetails?.LatestOrdinalEpisodeNumber;
|
|
public double? VoteAverage => CachedDetails?.VoteAverage;
|
|
|
|
// --- Anilist ---------------------------------------------------------
|
|
|
|
public bool HasAnilist => AnilistDetails != null;
|
|
public int? AnilistShowID => AnilistDetails?.ShowID;
|
|
public string? AnilistUrl => AnilistShowID.HasValue ? $"https://anilist.co/anime/{AnilistShowID}" : null;
|
|
|
|
/// <summary>Anilist's 0-100 score, rescaled to the 0-10 range TMDB uses.</summary>
|
|
public double? AnilistScore => AnilistDetails?.AverageScore.HasValue == true
|
|
? AnilistDetails.AverageScore!.Value / 10.0
|
|
: null;
|
|
|
|
public string? AnilistStatus => string.IsNullOrWhiteSpace(AnilistDetails?.Status)
|
|
? null
|
|
// Anilist statuses arrive as enum names like RELEASING / NOT_YET_RELEASED.
|
|
: string.Join(' ', AnilistDetails.Status.Split('_', StringSplitOptions.RemoveEmptyEntries)
|
|
.Select(word => char.ToUpperInvariant(word[0]) + word[1..].ToLowerInvariant()));
|
|
|
|
public int? SeasonYear => AnilistDetails?.SeasonYear;
|
|
|
|
/// <summary>Total episode count, preferring Anilist which the announcer treats as more reliable.</summary>
|
|
public int? TotalEpisodes => AnilistDetails?.Episodes ?? (LastEpisodeNumber > 0 ? LastEpisodeNumber : null);
|
|
|
|
/// <summary>Alternate titles worth showing, i.e. anything that is not just the display title again.</summary>
|
|
public List<string> AlternateTitles
|
|
{
|
|
get
|
|
{
|
|
var candidates = new[] { AnilistDetails?.RomajiTitle, AnilistDetails?.NativeTitle, AnilistDetails?.EnglishTitle };
|
|
return candidates
|
|
.Where(t => !string.IsNullOrWhiteSpace(t))
|
|
.Select(t => t!.Trim())
|
|
.Where(t => !string.Equals(t, Title, StringComparison.OrdinalIgnoreCase))
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
.ToList();
|
|
}
|
|
}
|
|
|
|
// --- Genres & tags ---------------------------------------------------
|
|
|
|
/// <summary>How many tags are shown before the rest are tucked behind a "more" toggle.</summary>
|
|
public const int VisibleTagCount = 10;
|
|
|
|
/// <summary>
|
|
/// Genres from both sources, AniList first. TMDB's "Animation" genre is dropped since every
|
|
/// show on this page is anime, so it carries no information.
|
|
/// </summary>
|
|
public List<string> Genres => MergeDistinct(AnilistDetails?.Genres, CachedDetails?.Genres)
|
|
.Where(g => !string.Equals(g, "Animation", StringComparison.OrdinalIgnoreCase))
|
|
.ToList();
|
|
|
|
/// <summary>AniList tags followed by TMDB keywords, minus anything already listed as a genre.</summary>
|
|
public List<string> Tags
|
|
{
|
|
get
|
|
{
|
|
var genres = new HashSet<string>(Genres, StringComparer.OrdinalIgnoreCase);
|
|
return MergeDistinct(AnilistDetails?.Tags, CachedDetails?.Keywords)
|
|
.Where(t => !genres.Contains(t))
|
|
.ToList();
|
|
}
|
|
}
|
|
|
|
public List<string> VisibleTags => Tags.Take(VisibleTagCount).ToList();
|
|
public List<string> OverflowTags => Tags.Skip(VisibleTagCount).ToList();
|
|
|
|
private static IEnumerable<string> MergeDistinct(params IEnumerable<string>?[] sources) =>
|
|
sources
|
|
.Where(s => s != null)
|
|
.SelectMany(s => s!)
|
|
.Where(s => !string.IsNullOrWhiteSpace(s))
|
|
.Select(s => s.Trim())
|
|
.Distinct(StringComparer.OrdinalIgnoreCase);
|
|
|
|
/// <summary>Anilist descriptions are HTML fragments; flatten them to plain text for display.</summary>
|
|
public string? AnilistDescription
|
|
{
|
|
get
|
|
{
|
|
if (string.IsNullOrWhiteSpace(AnilistDetails?.Description))
|
|
return null;
|
|
|
|
var text = AnilistDetails.Description
|
|
.Replace("<br>", " ", StringComparison.OrdinalIgnoreCase)
|
|
.Replace("<br/>", " ", StringComparison.OrdinalIgnoreCase)
|
|
.Replace("<br />", " ", StringComparison.OrdinalIgnoreCase);
|
|
text = WebUtility.HtmlDecode(HtmlTagPattern.Replace(text, string.Empty));
|
|
text = Regex.Replace(text, @"\s{2,}", " ").Trim();
|
|
|
|
return string.IsNullOrWhiteSpace(text) ? null : text;
|
|
}
|
|
}
|
|
|
|
public string? Overview => !string.IsNullOrWhiteSpace(CachedDetails?.LatestSeasonOverview)
|
|
? CachedDetails.LatestSeasonOverview
|
|
: (!string.IsNullOrWhiteSpace(CachedDetails?.Overview) ? CachedDetails.Overview : AnilistDescription);
|
|
|
|
/// <summary>True when <see cref="Overview"/> describes the current season rather than the series.</summary>
|
|
public bool OverviewIsSeasonSpecific => !string.IsNullOrWhiteSpace(CachedDetails?.LatestSeasonOverview);
|
|
|
|
// --- Artwork ---------------------------------------------------------
|
|
|
|
public string? SeasonPosterUrl => Clean(CachedDetails?.LatestSeasonPosterPath);
|
|
public string? ShowPosterUrl => Clean(CachedDetails?.PosterPath);
|
|
public string? BackdropUrl => Clean(CachedDetails?.BackdropPath);
|
|
public string? AnilistCoverUrl => Clean(AnilistDetails?.CoverImageUrl);
|
|
public string? AnilistBannerUrl => Clean(AnilistDetails?.BannerImageUrl);
|
|
|
|
/// <summary>The tall artwork shown alongside the entry; the season's own poster wins when present.</summary>
|
|
public string? PosterUrl => SeasonPosterUrl ?? ShowPosterUrl ?? AnilistCoverUrl;
|
|
|
|
/// <summary>The wide artwork used as the row background.</summary>
|
|
public string? HeroImageUrl => BackdropUrl ?? AnilistBannerUrl;
|
|
|
|
/// <summary>Every distinct piece of artwork, for the secondary thumbnail strip.</summary>
|
|
public List<ShowImage> Gallery
|
|
{
|
|
get
|
|
{
|
|
var images = new List<ShowImage>();
|
|
|
|
void Add(string? url, string label, string source)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(url))
|
|
return;
|
|
if (images.Any(i => string.Equals(i.Url, url, StringComparison.OrdinalIgnoreCase)))
|
|
return;
|
|
images.Add(new ShowImage { Url = url, Label = label, Source = source });
|
|
}
|
|
|
|
// The primary poster is already displayed beside the row, so start after it.
|
|
Add(SeasonPosterUrl, $"Season {LatestSeasonNumber} poster", "TMDB");
|
|
Add(ShowPosterUrl, "Series poster", "TMDB");
|
|
Add(AnilistCoverUrl, "Cover art", "AniList");
|
|
Add(BackdropUrl, "Backdrop", "TMDB");
|
|
Add(AnilistBannerUrl, "Banner", "AniList");
|
|
|
|
return images;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gallery entries other than the one already shown as the main poster.</summary>
|
|
public List<ShowImage> SecondaryImages =>
|
|
Gallery.Where(i => !string.Equals(i.Url, PosterUrl, StringComparison.OrdinalIgnoreCase)).ToList();
|
|
|
|
// --- Air dates -------------------------------------------------------
|
|
|
|
public DateTime AirReferenceNow => DateTime.Now;
|
|
|
|
public bool IsFuture
|
|
{
|
|
get
|
|
{
|
|
var date = EffectiveLastAirDate;
|
|
return date.HasValue && date.Value > AirReferenceNow;
|
|
}
|
|
}
|
|
|
|
public int DaysUntil
|
|
{
|
|
get
|
|
{
|
|
var date = EffectiveLastAirDate;
|
|
if (!date.HasValue)
|
|
return 0;
|
|
return (int)((date.Value - AirReferenceNow).Ticks / TimeSpan.FromDays(1).Ticks);
|
|
}
|
|
}
|
|
|
|
public string AirDateFormatted
|
|
{
|
|
get
|
|
{
|
|
var date = EffectiveLastAirDate;
|
|
return date.HasValue ? date.Value.ToString("MM/dd/yyyy") : "Unknown";
|
|
}
|
|
}
|
|
|
|
public string? AirDateLongFormatted => EffectiveLastAirDate?.ToString("dddd, MMMM d, yyyy");
|
|
|
|
/// <summary>How far into the season the latest aired episode sits, as a percentage.</summary>
|
|
public int? EpisodeProgressPercent
|
|
{
|
|
get
|
|
{
|
|
var total = TotalEpisodes;
|
|
if (!total.HasValue || total.Value <= 0 || LatestEpisodeNumber <= 0)
|
|
return null;
|
|
return (int)Math.Round(Math.Clamp(LatestEpisodeNumber / (double)total.Value, 0, 1) * 100);
|
|
}
|
|
}
|
|
|
|
/// <summary>True when the upcoming episode is the last one of the season.</summary>
|
|
public bool IsFinaleNext => TotalEpisodes.HasValue && LatestEpisodeNumber > 0 && LatestEpisodeNumber >= TotalEpisodes.Value;
|
|
|
|
private static string? Clean(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
|
|
}
|
|
}
|