jellyfin/MediaBrowser.Providers/Manager/ProviderUtils.cs

334 lines
12 KiB
C#
Raw Normal View History

using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
2015-06-29 01:10:45 +00:00
using MediaBrowser.Controller.Providers;
using MediaBrowser.Model.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using MediaBrowser.Controller.Extensions;
2014-02-08 20:02:35 +00:00
namespace MediaBrowser.Providers.Manager
{
public static class ProviderUtils
{
2015-06-29 01:10:45 +00:00
public static void MergeBaseItemData<T>(MetadataResult<T> sourceResult,
2016-04-13 20:49:16 +00:00
MetadataResult<T> targetResult,
List<MetadataFields> lockedFields,
bool replaceData,
2014-10-28 23:17:55 +00:00
bool mergeMetadataSettings)
2015-06-29 01:10:45 +00:00
where T : BaseItem
{
2015-06-29 01:10:45 +00:00
var source = sourceResult.Item;
var target = targetResult.Item;
2015-05-08 16:28:06 +00:00
if (source == null)
{
throw new ArgumentNullException("source");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (!lockedFields.Contains(MetadataFields.Name))
{
if (replaceData || string.IsNullOrEmpty(target.Name))
{
// Safeguard against incoming data having an emtpy name
if (!string.IsNullOrWhiteSpace(source.Name))
{
target.Name = source.Name;
}
}
}
2016-04-20 05:21:40 +00:00
if (replaceData || string.IsNullOrEmpty(target.OriginalTitle))
{
// Safeguard against incoming data having an emtpy name
if (!string.IsNullOrWhiteSpace(source.OriginalTitle))
{
target.OriginalTitle = source.OriginalTitle;
}
}
if (replaceData || !target.CommunityRating.HasValue)
{
target.CommunityRating = source.CommunityRating;
}
if (replaceData || !target.EndDate.HasValue)
{
target.EndDate = source.EndDate;
}
if (!lockedFields.Contains(MetadataFields.Genres))
{
if (replaceData || target.Genres.Count == 0)
{
target.Genres = source.Genres;
}
}
if (replaceData || string.IsNullOrEmpty(target.HomePageUrl))
{
target.HomePageUrl = source.HomePageUrl;
2014-10-09 22:22:04 +00:00
if (!string.IsNullOrWhiteSpace(target.HomePageUrl) && target.HomePageUrl.IndexOf("http", StringComparison.OrdinalIgnoreCase) != 0)
{
target.HomePageUrl = "http://" + target.HomePageUrl;
}
}
if (replaceData || !target.IndexNumber.HasValue)
{
target.IndexNumber = source.IndexNumber;
}
if (!lockedFields.Contains(MetadataFields.OfficialRating))
{
if (replaceData || string.IsNullOrEmpty(target.OfficialRating))
{
target.OfficialRating = source.OfficialRating;
}
}
2014-03-01 17:53:56 +00:00
if (replaceData || string.IsNullOrEmpty(target.CustomRating))
{
target.CustomRating = source.CustomRating;
}
2016-04-13 20:49:16 +00:00
2016-10-08 05:57:38 +00:00
if (replaceData || string.IsNullOrEmpty(target.Tagline))
{
target.Tagline = source.Tagline;
}
if (!lockedFields.Contains(MetadataFields.Overview))
{
if (replaceData || string.IsNullOrEmpty(target.Overview))
{
target.Overview = source.Overview;
}
}
if (replaceData || !target.ParentIndexNumber.HasValue)
{
target.ParentIndexNumber = source.ParentIndexNumber;
}
if (!lockedFields.Contains(MetadataFields.Cast))
{
2015-07-24 02:48:10 +00:00
if (replaceData || targetResult.People == null || targetResult.People.Count == 0)
{
2016-04-13 20:49:16 +00:00
targetResult.People = sourceResult.People;
}
else if (targetResult.People != null && sourceResult.People != null)
{
MergePeople(sourceResult.People, targetResult.People);
}
}
if (replaceData || !target.PremiereDate.HasValue)
{
target.PremiereDate = source.PremiereDate;
}
if (replaceData || !target.ProductionYear.HasValue)
{
target.ProductionYear = source.ProductionYear;
}
if (!lockedFields.Contains(MetadataFields.Runtime))
{
if (replaceData || !target.RunTimeTicks.HasValue)
{
if (!(target is Audio) && !(target is Video))
{
target.RunTimeTicks = source.RunTimeTicks;
}
}
}
if (!lockedFields.Contains(MetadataFields.Studios))
{
if (replaceData || target.Studios.Count == 0)
{
target.Studios = source.Studios;
}
}
2014-01-31 04:50:09 +00:00
if (!lockedFields.Contains(MetadataFields.Tags))
{
2016-06-02 17:43:29 +00:00
if (replaceData || target.Tags.Count == 0)
2014-01-31 04:50:09 +00:00
{
2016-06-02 17:43:29 +00:00
target.Tags = source.Tags;
2014-01-31 04:50:09 +00:00
}
}
if (!lockedFields.Contains(MetadataFields.Keywords))
{
if (replaceData || target.Keywords.Count == 0)
2014-01-31 04:50:09 +00:00
{
target.Keywords = source.Keywords;
2014-01-31 04:50:09 +00:00
}
}
2016-10-09 07:18:43 +00:00
if (!lockedFields.Contains(MetadataFields.ProductionLocations))
{
if (replaceData || target.ProductionLocations.Count == 0)
{
target.ProductionLocations = source.ProductionLocations;
}
}
foreach (var id in source.ProviderIds)
{
2014-02-13 05:11:54 +00:00
var key = id.Key;
// Don't replace existing Id's.
2014-07-08 01:41:03 +00:00
if (replaceData || !target.ProviderIds.ContainsKey(key))
2014-02-13 05:11:54 +00:00
{
target.ProviderIds[key] = id.Value;
}
}
MergeAlbumArtist(source, target, lockedFields, replaceData);
MergeCriticRating(source, target, lockedFields, replaceData);
MergeTrailers(source, target, lockedFields, replaceData);
2017-05-09 18:51:26 +00:00
MergeVideoInfo(source, target, lockedFields, replaceData);
2017-06-03 07:36:32 +00:00
MergeDisplayOrder(source, target, lockedFields, replaceData);
//if (!lockedFields.Contains(MetadataFields.SortName))
{
if (replaceData || string.IsNullOrEmpty(target.ForcedSortName))
{
var forcedSortName = source.ForcedSortName;
if (!string.IsNullOrWhiteSpace(forcedSortName))
{
target.ForcedSortName = forcedSortName;
}
}
}
//if (!lockedFields.Contains(MetadataFields.DisplayMediaType))
{
if (replaceData || string.IsNullOrEmpty(target.DisplayMediaType))
{
// Safeguard against incoming data having an emtpy name
if (!string.IsNullOrWhiteSpace(source.DisplayMediaType))
{
target.DisplayMediaType = source.DisplayMediaType;
}
}
}
if (mergeMetadataSettings)
{
2014-10-28 23:17:55 +00:00
MergeMetadataSettings(source, target);
}
}
2014-01-31 04:50:09 +00:00
private static void MergePeople(List<PersonInfo> source, List<PersonInfo> target)
{
foreach (var person in target)
{
var normalizedName = person.Name.RemoveDiacritics();
var personInSource = source.FirstOrDefault(i => string.Equals(i.Name.RemoveDiacritics(), normalizedName, StringComparison.OrdinalIgnoreCase));
if (personInSource != null)
{
foreach (var providerId in personInSource.ProviderIds)
{
if (!person.ProviderIds.ContainsKey(providerId.Key))
{
person.ProviderIds[providerId.Key] = providerId.Value;
}
}
if (string.IsNullOrWhiteSpace(person.ImageUrl))
{
person.ImageUrl = personInSource.ImageUrl;
}
}
}
}
2014-10-28 23:17:55 +00:00
public static void MergeMetadataSettings(BaseItem source,
BaseItem target)
{
target.LockedFields = source.LockedFields;
target.IsLocked = source.IsLocked;
2014-05-02 02:54:33 +00:00
2014-10-28 23:17:55 +00:00
// Grab the value if it's there, but if not then don't overwrite the default
if (source.DateCreated != default(DateTime))
{
target.DateCreated = source.DateCreated;
}
2014-01-31 04:50:09 +00:00
2015-09-29 17:35:23 +00:00
target.PreferredMetadataCountryCode = source.PreferredMetadataCountryCode;
target.PreferredMetadataLanguage = source.PreferredMetadataLanguage;
2017-06-03 07:36:32 +00:00
}
2014-01-31 04:50:09 +00:00
2017-06-03 07:36:32 +00:00
private static void MergeDisplayOrder(BaseItem source, BaseItem target, List<MetadataFields> lockedFields, bool replaceData)
{
2014-10-28 23:17:55 +00:00
var sourceHasDisplayOrder = source as IHasDisplayOrder;
var targetHasDisplayOrder = target as IHasDisplayOrder;
if (sourceHasDisplayOrder != null && targetHasDisplayOrder != null)
{
targetHasDisplayOrder.DisplayOrder = sourceHasDisplayOrder.DisplayOrder;
}
}
2016-04-13 20:49:16 +00:00
private static void MergeAlbumArtist(BaseItem source, BaseItem target, List<MetadataFields> lockedFields, bool replaceData)
{
var sourceHasAlbumArtist = source as IHasAlbumArtist;
var targetHasAlbumArtist = target as IHasAlbumArtist;
if (sourceHasAlbumArtist != null && targetHasAlbumArtist != null)
{
2015-03-13 01:55:22 +00:00
if (replaceData || targetHasAlbumArtist.AlbumArtists.Count == 0)
{
2014-06-23 16:05:19 +00:00
targetHasAlbumArtist.AlbumArtists = sourceHasAlbumArtist.AlbumArtists;
}
}
}
private static void MergeCriticRating(BaseItem source, BaseItem target, List<MetadataFields> lockedFields, bool replaceData)
{
2016-10-17 16:35:29 +00:00
if (replaceData || !target.CriticRating.HasValue)
{
2016-10-17 16:35:29 +00:00
target.CriticRating = source.CriticRating;
}
}
private static void MergeTrailers(BaseItem source, BaseItem target, List<MetadataFields> lockedFields, bool replaceData)
{
var sourceCast = source as IHasTrailers;
var targetCast = target as IHasTrailers;
if (sourceCast != null && targetCast != null)
{
if (replaceData || targetCast.RemoteTrailers.Count == 0)
{
targetCast.RemoteTrailers = sourceCast.RemoteTrailers;
}
}
}
2017-05-09 18:51:26 +00:00
private static void MergeVideoInfo(BaseItem source, BaseItem target, List<MetadataFields> lockedFields, bool replaceData)
{
var sourceCast = source as Video;
var targetCast = target as Video;
if (sourceCast != null && targetCast != null)
{
if (replaceData || targetCast.Video3DFormat == null)
{
targetCast.Video3DFormat = sourceCast.Video3DFormat;
}
}
}
}
}