2020-06-19 14:24:13 -04:00
|
|
|
#pragma warning disable CS1591
|
|
|
|
|
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;
|
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);
|
|
|
|
|
|
|
|
RemoveObsoleteSeasons(item);
|
|
|
|
await FillInMissingSeasonsAsync(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
|
|
|
{
|
|
|
|
ProviderUtils.MergeBaseItemData(source, target, lockedFields, replaceData, mergeMetadataSettings);
|
|
|
|
|
|
|
|
var sourceItem = source.Item;
|
|
|
|
var targetItem = target.Item;
|
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
|
|
|
|
|
|
|
if (replaceData || targetItem.AirDays == null || targetItem.AirDays.Length == 0)
|
|
|
|
{
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
// TODO Legacy. It's not really "physical" seasons as any virtual seasons are always converted to non-virtual in FillInMissingSeasonsAsync.
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Creates seasons for all episodes that aren't in a season folder.
|
|
|
|
/// If no season number can be determined, a dummy season will be created.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="series">The series.</param>
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
/// <returns>The async task.</returns>
|
|
|
|
private async Task FillInMissingSeasonsAsync(Series series, CancellationToken cancellationToken)
|
|
|
|
{
|
|
|
|
var episodesInSeriesFolder = series.GetRecursiveChildren(i => i is Episode)
|
|
|
|
.Cast<Episode>()
|
|
|
|
.Where(i => !i.IsInSeasonFolder);
|
|
|
|
|
|
|
|
List<Season> seasons = series.Children.OfType<Season>().ToList();
|
|
|
|
|
|
|
|
// Loop through the unique season numbers
|
|
|
|
foreach (var episode in episodesInSeriesFolder)
|
|
|
|
{
|
|
|
|
// Null season numbers will have a 'dummy' season created because seasons are always required.
|
|
|
|
var seasonNumber = episode.ParentIndexNumber >= 0 ? episode.ParentIndexNumber : null;
|
|
|
|
var existingSeason = seasons.FirstOrDefault(i => i.IndexNumber == seasonNumber);
|
|
|
|
|
|
|
|
if (existingSeason == null)
|
|
|
|
{
|
|
|
|
var season = await CreateSeasonAsync(series, seasonNumber, cancellationToken).ConfigureAwait(false);
|
|
|
|
seasons.Add(season);
|
|
|
|
}
|
|
|
|
else if (existingSeason.IsVirtualItem)
|
|
|
|
{
|
|
|
|
existingSeason.IsVirtualItem = false;
|
|
|
|
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>
|
|
|
|
/// <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,
|
|
|
|
int? seasonNumber,
|
|
|
|
CancellationToken cancellationToken)
|
|
|
|
{
|
|
|
|
string seasonName = seasonNumber switch
|
|
|
|
{
|
|
|
|
null => _localizationManager.GetLocalizedString("NameSeasonUnknown"),
|
|
|
|
0 => LibraryManager.GetLibraryOptions(series).SeasonZeroDisplayName,
|
|
|
|
_ => string.Format(CultureInfo.InvariantCulture, _localizationManager.GetLocalizedString("NameSeasonNumber"), seasonNumber.Value)
|
|
|
|
};
|
|
|
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
|
|
series.AddChild(season, cancellationToken);
|
|
|
|
|
|
|
|
await season.RefreshMetadata(new MetadataRefreshOptions(new DirectoryService(FileSystem)), cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
return season;
|
|
|
|
}
|
2014-02-03 15:51:28 -05:00
|
|
|
}
|
|
|
|
}
|