public ProcessFailedResult(string sourceName, string mediaItemName, IMediaItemType mediaItemType, string reason)
{
this.SourceName = sourceName;
this.MediaItemName = mediaItemName;
this.MediaItemType = mediaItemType;
this.Reason = reason;
}
private MediaItem(IEmbyItemData embyData, IMediaItemType itemType,
ImmutableDictionary <string, ISourceData> sourceData)
{
EmbyData = embyData;
ItemType = itemType;
_sourceData = sourceData;
}
public IEnumerator GetEnumerator()
{
var cases = new IMediaItemType[] { MediaItemTypes.Series, MediaItemTypes.Season, MediaItemTypes.Episode };
foreach (var mediaItemType in cases)
{
yield return(mediaItemType);
}
}
public EmbyItemData(IMediaItemType itemType, IItemIdentifier identifier, IDictionary <string, int> existingIds,
string language, IEnumerable <EmbyItemId> parentIds)
{
this.ParentIds = parentIds;
this.ItemType = itemType;
this.Identifier = identifier;
this.Language = language;
this.ExistingIds = existingIds ?? new Dictionary <string, int>();
}
private EmbyItemData ToEmbyItemData <TEmbyItem>(ItemLookupInfo embyInfo, IMediaItemType <TEmbyItem> itemType,
IEnumerable <EmbyItemId> parentIds)
where TEmbyItem : BaseItem
{
var existingIds = embyInfo.ProviderIds.Where(v => int.TryParse(v.Value, out _))
.ToDictionary(k => k.Key, v => int.Parse(v.Value));
return(new EmbyItemData(itemType,
new ItemIdentifier(embyInfo.IndexNumber.ToOption(), embyInfo.ParentIndexNumber.ToOption(),
embyInfo.Name), existingIds, embyInfo.MetadataLanguage, parentIds));
}
/// <summary>
/// Create a new <see cref="MediaItem" />
/// </summary>
/// <param name="embyData">The name of the item as originally provided by Emby</param>
/// <param name="itemType">The type of the media item</param>
/// <param name="sourceData">The metadata from the source used to initially identify this media item</param>
public MediaItem(IEmbyItemData embyData, IMediaItemType itemType, ISourceData sourceData)
{
if (sourceData == null)
{
throw new ArgumentNullException(nameof(sourceData));
}
this.EmbyData = embyData ?? throw new ArgumentNullException(nameof(embyData));
this.ItemType = itemType;
this.sourceData = ImmutableDictionary <string, ISourceData> .Empty.Add(sourceData.Source.Name, sourceData);
}
public void GetEmbySourceDataLoader_MatchingLoader_ReturnsLoader(IMediaItemType mediaItemType)
{
var loader = Substitute.For <IEmbySourceDataLoader>();
loader.SourceName.Returns(SourceNames.TvDb);
loader.CanLoadFrom(mediaItemType).Returns(true);
_loaders.Add(loader);
var result = _tvDbSource.GetEmbySourceDataLoader(mediaItemType);
result.IsRight.Should().BeTrue();
result.IfRight(r => r.Should().BeSameAs(loader));
}
public void GetEmbySourceDataLoader_NoMatchingLoader_ReturnsFailed(IMediaItemType mediaItemType)
{
var sourceMismatch = Substitute.For <IEmbySourceDataLoader>();
sourceMismatch.SourceName.Returns(SourceNames.AniDb);
sourceMismatch.CanLoadFrom(mediaItemType).Returns(true);
var cannotLoad = Substitute.For <IEmbySourceDataLoader>();
cannotLoad.SourceName.Returns(SourceNames.TvDb);
cannotLoad.CanLoadFrom(mediaItemType).Returns(false);
_loaders.Add(sourceMismatch);
_loaders.Add(cannotLoad);
var result = _tvDbSource.GetEmbySourceDataLoader(mediaItemType);
result.IsLeft.Should().BeTrue();
result.IfLeft(f => f.Reason.Should().Be("No Emby source data loader for this source and media item type"));
}
public Task <Either <ProcessFailedResult, IMetadataFoundResult <TEmbyItem> > > GetResultAsync <TEmbyItem>(
ItemLookupInfo embyInfo, IMediaItemType <TEmbyItem> itemType, IEnumerable <EmbyItemId> parentIds)
where TEmbyItem : BaseItem
{
var embyItemData = this.ToEmbyItemData(embyInfo, itemType, parentIds);
this.log.Debug($"Finding metadata for {embyItemData}");
var mediaItem = this.mediaItemBuilder.Identify(embyItemData, itemType);
var fullyRecognisedMediaItem = mediaItem.BindAsync(this.mediaItemBuilder.BuildMediaItem);
return(fullyRecognisedMediaItem.BindAsync(
mi => itemType.CreateMetadataFoundResult(this.pluginConfiguration, mi, this.logManager))
.MapAsync(r =>
{
this.log.Debug(
$"Created metadata with provider Ids: {string.Join(", ", r.EmbyMetadataResult.Item.ProviderIds.Select(kvp => $"{kvp.Key}: {kvp.Value}"))}");
return r;
}));
}
/// <summary>
/// Get the id of the parent of the specified item type for a particular source
/// </summary>
public Option <int> GetParentId(IMediaItemType itemType, ISource source)
{
var parentId = this.ParentIds.Find(id => id.ItemType == itemType && id.SourceName == source.Name);
return(parentId.Map(id => id.Id));
}
public EmbyItemId(IMediaItemType itemType, string sourceName, int id)
{
ItemType = itemType;
SourceName = sourceName;
Id = id;
}
private Task <Either <ProcessFailedResult, ISourceData> > IdentifyAsync(EmbyItemData embyItemData, IMediaItemType itemType)
{
var identifyingSource = this.pluginConfiguration.FileStructureSource(itemType);
return(identifyingSource.GetEmbySourceDataLoader(embyItemData.ItemType)
.BindAsync(l => l.LoadFrom(embyItemData)));
}
public bool ShouldUsePlaceholderSourceData(IMediaItemType mediaItemType)
{
return(false);
}
public Either <ProcessFailedResult, IEmbySourceDataLoader> GetEmbySourceDataLoader(IMediaItemType mediaItemType)
{
return(_sourceImplementation.GetEmbySourceDataLoader(mediaItemType));
}
public IdentifierOnlySourceData(ISource source, Option <int> id, IItemIdentifier identifier, IMediaItemType itemType)
{
this.Source = source ?? throw new ArgumentNullException(nameof(source));
this.Id = id;
this.Identifier = identifier ?? throw new ArgumentNullException(nameof(identifier));
this.ItemType = itemType;
}
public EmbyItemId(IMediaItemType itemType, string sourceName, int id)
{
this.ItemType = itemType;
this.SourceName = sourceName;
this.Id = id;
}
public bool CanLoadFrom(IMediaItemType mediaItemType)
{
return(mediaItemType == MediaItemTypes.Series);
}
public bool ShouldUsePlaceholderSourceData(IMediaItemType mediaItemType)
{
return(mediaItemType == MediaItemTypes.Series);
}
public Task <Either <ProcessFailedResult, IMediaItem> > IdentifyAsync(EmbyItemData embyItemData,
IMediaItemType itemType)
{
return(IdentifyAsync(embyItemData).MapAsync(sd => (IMediaItem) new MediaItem(embyItemData, itemType, sd)));
}
public bool CanLoadFrom(IMediaItemType mediaItemType)
{
return(mediaItemType == MediaItemTypes.Episode);
}
public Either <ProcessFailedResult, IEmbySourceDataLoader> GetEmbySourceDataLoader(IMediaItemType mediaItemType)
{
return(_embySourceDataLoaders.Find(l => l.SourceName == Name && l.CanLoadFrom(mediaItemType))
.ToEither(new ProcessFailedResult(Name, "", mediaItemType,
"No Emby source data loader for this source and media item type")));
}
public ProcessResultContext(string sourceName, string mediaItemName, IMediaItemType mediaItemType)
{
this.sourceName = sourceName;
this.mediaItemName = mediaItemName;
this.mediaItemType = mediaItemType;
}
