2020-06-19 14:24:13 -04:00
|
|
|
#pragma warning disable CS1591
|
|
|
|
|
2023-08-23 06:15:21 -04:00
|
|
|
using System;
|
2020-12-15 02:18:36 -05:00
|
|
|
using System.Collections.Generic;
|
|
|
|
using System.Globalization;
|
|
|
|
using System.Linq;
|
|
|
|
using System.Threading;
|
|
|
|
using System.Threading.Tasks;
|
2019-01-13 14:26:31 -05:00
|
|
|
using MediaBrowser.Controller.Configuration;
|
2022-08-01 14:25:46 -04:00
|
|
|
using MediaBrowser.Controller.Dto;
|
2014-02-03 15:51:28 -05:00
|
|
|
using MediaBrowser.Controller.Entities.TV;
|
|
|
|
using MediaBrowser.Controller.Library;
|
|
|
|
using MediaBrowser.Controller.Providers;
|
|
|
|
using MediaBrowser.Model.Entities;
|
2020-12-15 02:18:36 -05:00
|
|
|
using MediaBrowser.Model.Globalization;
|
2019-01-13 14:26:31 -05:00
|
|
|
using MediaBrowser.Model.IO;
|
|
|
|
using MediaBrowser.Providers.Manager;
|
|
|
|
using Microsoft.Extensions.Logging;
|
2014-02-03 15:51:28 -05:00
|
|
|
|
|
|
|
namespace MediaBrowser.Providers.TV
|
|
|
|
{
|
2014-02-09 02:27:44 -05:00
|
|
|
public class SeriesMetadataService : MetadataService<Series, SeriesInfo>
|
2014-02-03 15:51:28 -05:00
|
|
|
{
|
2020-12-15 02:18:36 -05:00
|
|
|
private readonly ILocalizationManager _localizationManager;
|
|
|
|
|
2019-02-15 14:11:27 -05:00
|
|
|
public SeriesMetadataService(
|
|
|
|
IServerConfigurationManager serverConfigurationManager,
|
2020-03-03 17:07:10 -05:00
|
|
|
ILogger<SeriesMetadataService> logger,
|
2019-02-15 14:11:27 -05:00
|
|
|
IProviderManager providerManager,
|
|
|
|
IFileSystem fileSystem,
|
2020-12-15 02:18:36 -05:00
|
|
|
ILibraryManager libraryManager,
|
|
|
|
ILocalizationManager localizationManager)
|
2019-09-10 16:37:53 -04:00
|
|
|
: base(serverConfigurationManager, logger, providerManager, fileSystem, libraryManager)
|
2014-02-03 15:51:28 -05:00
|
|
|
{
|
2020-12-15 02:18:36 -05:00
|
|
|
_localizationManager = localizationManager;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <inheritdoc />
|
|
|
|
protected override async Task AfterMetadataRefresh(Series item, MetadataRefreshOptions refreshOptions, CancellationToken cancellationToken)
|
|
|
|
{
|
|
|
|
await base.AfterMetadataRefresh(item, refreshOptions, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
2022-08-01 14:25:46 -04:00
|
|
|
RemoveObsoleteEpisodes(item);
|
2020-12-15 02:18:36 -05:00
|
|
|
RemoveObsoleteSeasons(item);
|
2022-08-02 11:46:38 -04:00
|
|
|
await UpdateAndCreateSeasonsAsync(item, cancellationToken).ConfigureAwait(false);
|
2015-06-28 21:10:45 -04:00
|
|
|
}
|
2014-02-17 16:35:08 -05:00
|
|
|
|
2019-09-10 16:37:53 -04:00
|
|
|
/// <inheritdoc />
|
2015-06-28 21:10:45 -04:00
|
|
|
protected override bool IsFullLocalMetadata(Series item)
|
|
|
|
{
|
|
|
|
if (string.IsNullOrWhiteSpace(item.Overview))
|
2014-02-17 16:35:08 -05:00
|
|
|
{
|
2015-06-28 21:10:45 -04:00
|
|
|
return false;
|
2014-02-17 16:35:08 -05:00
|
|
|
}
|
2020-06-15 17:43:52 -04:00
|
|
|
|
2015-06-28 21:10:45 -04:00
|
|
|
if (!item.ProductionYear.HasValue)
|
2014-02-17 16:35:08 -05:00
|
|
|
{
|
2015-06-28 21:10:45 -04:00
|
|
|
return false;
|
2014-02-17 16:35:08 -05:00
|
|
|
}
|
2020-06-15 17:43:52 -04:00
|
|
|
|
2015-06-28 21:10:45 -04:00
|
|
|
return base.IsFullLocalMetadata(item);
|
|
|
|
}
|
|
|
|
|
2019-09-10 16:37:53 -04:00
|
|
|
/// <inheritdoc />
|
2020-06-09 18:12:53 -04:00
|
|
|
protected override void MergeData(MetadataResult<Series> source, MetadataResult<Series> target, MetadataField[] lockedFields, bool replaceData, bool mergeMetadataSettings)
|
2015-06-28 21:10:45 -04:00
|
|
|
{
|
2021-12-24 09:30:52 -05:00
|
|
|
base.MergeData(source, target, lockedFields, replaceData, mergeMetadataSettings);
|
2015-06-28 21:10:45 -04:00
|
|
|
|
|
|
|
var sourceItem = source.Item;
|
|
|
|
var targetItem = target.Item;
|
2022-08-02 11:46:38 -04:00
|
|
|
var sourceSeasonNames = sourceItem.SeasonNames;
|
|
|
|
var targetSeasonNames = targetItem.SeasonNames;
|
|
|
|
|
|
|
|
if (replaceData || targetSeasonNames.Count == 0)
|
|
|
|
{
|
|
|
|
targetItem.SeasonNames = sourceSeasonNames;
|
|
|
|
}
|
|
|
|
else if (targetSeasonNames.Count != sourceSeasonNames.Count || !sourceSeasonNames.Keys.All(targetSeasonNames.ContainsKey))
|
|
|
|
{
|
2023-06-10 09:04:23 -04:00
|
|
|
foreach (var (number, name) in sourceSeasonNames)
|
2022-08-02 11:46:38 -04:00
|
|
|
{
|
2023-06-10 09:04:23 -04:00
|
|
|
targetSeasonNames.TryAdd(number, name);
|
2022-08-02 11:46:38 -04:00
|
|
|
}
|
|
|
|
}
|
2014-02-17 16:35:08 -05:00
|
|
|
|
2017-08-13 16:15:07 -04:00
|
|
|
if (replaceData || string.IsNullOrEmpty(targetItem.AirTime))
|
|
|
|
{
|
|
|
|
targetItem.AirTime = sourceItem.AirTime;
|
|
|
|
}
|
|
|
|
|
2015-06-28 21:10:45 -04:00
|
|
|
if (replaceData || !targetItem.Status.HasValue)
|
2015-01-28 16:29:02 -05:00
|
|
|
{
|
2015-06-28 21:10:45 -04:00
|
|
|
targetItem.Status = sourceItem.Status;
|
2015-01-28 16:29:02 -05:00
|
|
|
}
|
2017-08-13 16:15:07 -04:00
|
|
|
|
2022-12-05 09:00:20 -05:00
|
|
|
if (replaceData || targetItem.AirDays is null || targetItem.AirDays.Length == 0)
|
2017-08-13 16:15:07 -04:00
|
|
|
{
|
|
|
|
targetItem.AirDays = sourceItem.AirDays;
|
|
|
|
}
|
2015-02-25 13:11:49 -05:00
|
|
|
}
|
2020-12-15 02:18:36 -05:00
|
|
|
|
|
|
|
private void RemoveObsoleteSeasons(Series series)
|
|
|
|
{
|
2022-08-02 11:46:38 -04:00
|
|
|
// TODO Legacy. It's not really "physical" seasons as any virtual seasons are always converted to non-virtual in UpdateAndCreateSeasonsAsync.
|
2020-12-15 02:18:36 -05:00
|
|
|
var physicalSeasonNumbers = new HashSet<int>();
|
|
|
|
var virtualSeasons = new List<Season>();
|
|
|
|
foreach (var existingSeason in series.Children.OfType<Season>())
|
|
|
|
{
|
|
|
|
if (existingSeason.LocationType != LocationType.Virtual && existingSeason.IndexNumber.HasValue)
|
|
|
|
{
|
|
|
|
physicalSeasonNumbers.Add(existingSeason.IndexNumber.Value);
|
|
|
|
}
|
|
|
|
else if (existingSeason.LocationType == LocationType.Virtual)
|
|
|
|
{
|
|
|
|
virtualSeasons.Add(existingSeason);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (var virtualSeason in virtualSeasons)
|
|
|
|
{
|
|
|
|
var seasonNumber = virtualSeason.IndexNumber;
|
|
|
|
// If there's a physical season with the same number or no episodes in the season, delete it
|
|
|
|
if ((seasonNumber.HasValue && physicalSeasonNumbers.Contains(seasonNumber.Value))
|
|
|
|
|| !virtualSeason.GetEpisodes().Any())
|
|
|
|
{
|
|
|
|
Logger.LogInformation("Removing virtual season {SeasonNumber} in series {SeriesName}", virtualSeason.IndexNumber, series.Name);
|
|
|
|
|
|
|
|
LibraryManager.DeleteItem(
|
|
|
|
virtualSeason,
|
|
|
|
new DeleteOptions
|
|
|
|
{
|
|
|
|
DeleteFileLocation = true
|
|
|
|
},
|
|
|
|
false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-01 14:25:46 -04:00
|
|
|
private void RemoveObsoleteEpisodes(Series series)
|
|
|
|
{
|
|
|
|
var episodes = series.GetEpisodes(null, new DtoOptions()).OfType<Episode>().ToList();
|
|
|
|
var numberOfEpisodes = episodes.Count;
|
|
|
|
// TODO: O(n^2), but can it be done faster without overcomplicating it?
|
|
|
|
for (var i = 0; i < numberOfEpisodes; i++)
|
|
|
|
{
|
|
|
|
var currentEpisode = episodes[i];
|
|
|
|
// The outer loop only examines virtual episodes
|
|
|
|
if (!currentEpisode.IsVirtualItem)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Virtual episodes without an episode number are practically orphaned and should be deleted
|
|
|
|
if (!currentEpisode.IndexNumber.HasValue)
|
|
|
|
{
|
|
|
|
DeleteEpisode(currentEpisode);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (var j = i + 1; j < numberOfEpisodes; j++)
|
|
|
|
{
|
|
|
|
var comparisonEpisode = episodes[j];
|
|
|
|
// The inner loop is only for "physical" episodes
|
|
|
|
if (comparisonEpisode.IsVirtualItem
|
|
|
|
|| currentEpisode.ParentIndexNumber != comparisonEpisode.ParentIndexNumber
|
|
|
|
|| !comparisonEpisode.ContainsEpisodeNumber(currentEpisode.IndexNumber.Value))
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
DeleteEpisode(currentEpisode);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void DeleteEpisode(Episode episode)
|
|
|
|
{
|
|
|
|
Logger.LogInformation(
|
|
|
|
"Removing virtual episode S{SeasonNumber}E{EpisodeNumber} in series {SeriesName}",
|
|
|
|
episode.ParentIndexNumber,
|
|
|
|
episode.IndexNumber,
|
|
|
|
episode.SeriesName);
|
|
|
|
|
|
|
|
LibraryManager.DeleteItem(
|
|
|
|
episode,
|
|
|
|
new DeleteOptions
|
|
|
|
{
|
|
|
|
DeleteFileLocation = true
|
|
|
|
},
|
|
|
|
false);
|
|
|
|
}
|
|
|
|
|
2020-12-15 02:18:36 -05:00
|
|
|
/// <summary>
|
2022-08-02 11:46:38 -04:00
|
|
|
/// Creates seasons for all episodes if they don't exist.
|
2020-12-15 02:18:36 -05:00
|
|
|
/// If no season number can be determined, a dummy season will be created.
|
2022-08-02 11:46:38 -04:00
|
|
|
/// Updates seasons names.
|
2020-12-15 02:18:36 -05:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="series">The series.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>The async task.</returns>
|
2022-08-02 11:46:38 -04:00
|
|
|
private async Task UpdateAndCreateSeasonsAsync(Series series, CancellationToken cancellationToken)
|
2020-12-15 02:18:36 -05:00
|
|
|
{
|
2022-08-02 11:46:38 -04:00
|
|
|
var seasonNames = series.SeasonNames;
|
2021-11-28 13:56:31 -05:00
|
|
|
var seriesChildren = series.GetRecursiveChildren(i => i is Episode || i is Season);
|
2022-08-02 11:46:38 -04:00
|
|
|
var seasons = seriesChildren.OfType<Season>().ToList();
|
|
|
|
var uniqueSeasonNumbers = seriesChildren
|
2021-11-28 13:56:31 -05:00
|
|
|
.OfType<Episode>()
|
2022-08-02 11:46:38 -04:00
|
|
|
.Select(e => e.ParentIndexNumber >= 0 ? e.ParentIndexNumber : null)
|
|
|
|
.Distinct();
|
2020-12-15 02:18:36 -05:00
|
|
|
|
|
|
|
// Loop through the unique season numbers
|
2022-08-02 11:46:38 -04:00
|
|
|
foreach (var seasonNumber in uniqueSeasonNumbers)
|
2020-12-15 02:18:36 -05:00
|
|
|
{
|
|
|
|
// Null season numbers will have a 'dummy' season created because seasons are always required.
|
|
|
|
var existingSeason = seasons.FirstOrDefault(i => i.IndexNumber == seasonNumber);
|
2022-08-02 11:46:38 -04:00
|
|
|
string? seasonName = null;
|
|
|
|
|
2023-05-21 07:52:43 -04:00
|
|
|
if (seasonNumber.HasValue && seasonNames.TryGetValue(seasonNumber.Value, out var tmp))
|
2022-08-02 11:46:38 -04:00
|
|
|
{
|
2023-05-21 07:52:43 -04:00
|
|
|
seasonName = tmp;
|
2022-08-02 11:46:38 -04:00
|
|
|
}
|
2020-12-15 02:18:36 -05:00
|
|
|
|
2022-12-05 09:00:20 -05:00
|
|
|
if (existingSeason is null)
|
2020-12-15 02:18:36 -05:00
|
|
|
{
|
2022-08-02 11:46:38 -04:00
|
|
|
var season = await CreateSeasonAsync(series, seasonName, seasonNumber, cancellationToken).ConfigureAwait(false);
|
|
|
|
series.AddChild(season);
|
2020-12-15 02:18:36 -05:00
|
|
|
}
|
2022-08-02 11:46:38 -04:00
|
|
|
else
|
2020-12-15 02:18:36 -05:00
|
|
|
{
|
2023-08-23 06:15:21 -04:00
|
|
|
var name = GetValidSeasonNameForSeries(series, seasonName, seasonNumber);
|
|
|
|
if (string.Equals(existingSeason.Name, name, StringComparison.Ordinal))
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
existingSeason.Name = name;
|
2020-12-15 02:18:36 -05:00
|
|
|
await existingSeason.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Creates a new season, adds it to the database by linking it to the [series] and refreshes the metadata.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="series">The series.</param>
|
2022-08-02 11:46:38 -04:00
|
|
|
/// <param name="seasonName">The season name.</param>
|
2020-12-15 02:18:36 -05:00
|
|
|
/// <param name="seasonNumber">The season number.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>The newly created season.</returns>
|
|
|
|
private async Task<Season> CreateSeasonAsync(
|
|
|
|
Series series,
|
2022-08-02 11:46:38 -04:00
|
|
|
string? seasonName,
|
2020-12-15 02:18:36 -05:00
|
|
|
int? seasonNumber,
|
|
|
|
CancellationToken cancellationToken)
|
|
|
|
{
|
2022-08-02 11:46:38 -04:00
|
|
|
seasonName = GetValidSeasonNameForSeries(series, seasonName, seasonNumber);
|
2020-12-15 02:18:36 -05:00
|
|
|
Logger.LogInformation("Creating Season {SeasonName} entry for {SeriesName}", seasonName, series.Name);
|
|
|
|
|
|
|
|
var season = new Season
|
|
|
|
{
|
|
|
|
Name = seasonName,
|
|
|
|
IndexNumber = seasonNumber,
|
|
|
|
Id = LibraryManager.GetNewItemId(
|
|
|
|
series.Id + (seasonNumber ?? -1).ToString(CultureInfo.InvariantCulture) + seasonName,
|
|
|
|
typeof(Season)),
|
|
|
|
IsVirtualItem = false,
|
|
|
|
SeriesId = series.Id,
|
|
|
|
SeriesName = series.Name
|
|
|
|
};
|
|
|
|
|
2021-07-10 12:09:02 -04:00
|
|
|
series.AddChild(season);
|
2020-12-15 02:18:36 -05:00
|
|
|
|
|
|
|
await season.RefreshMetadata(new MetadataRefreshOptions(new DirectoryService(FileSystem)), cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
return season;
|
|
|
|
}
|
2022-08-02 11:46:38 -04:00
|
|
|
|
|
|
|
private string GetValidSeasonNameForSeries(Series series, string? seasonName, int? seasonNumber)
|
|
|
|
{
|
|
|
|
if (string.IsNullOrEmpty(seasonName))
|
|
|
|
{
|
|
|
|
seasonName = seasonNumber switch
|
|
|
|
{
|
|
|
|
null => _localizationManager.GetLocalizedString("NameSeasonUnknown"),
|
|
|
|
0 => LibraryManager.GetLibraryOptions(series).SeasonZeroDisplayName,
|
|
|
|
_ => string.Format(CultureInfo.InvariantCulture, _localizationManager.GetLocalizedString("NameSeasonNumber"), seasonNumber.Value)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
return seasonName;
|
|
|
|
}
|
2014-02-03 15:51:28 -05:00
|
|
|
}
|
|
|
|
}
|