public void TestAudioItem()
{
IList <IDirectoryObject> objects = new List <IDirectoryObject>();
Guid id = new Guid("11111111-aaaa-aaaa-aaaa-111111111111");
IDictionary <Guid, IList <MediaItemAspect> > aspects = new Dictionary <Guid, IList <MediaItemAspect> >();
SingleMediaItemAspect aspect1 = new SingleMediaItemAspect(MediaAspect.Metadata);
aspect1.SetAttribute(MediaAspect.ATTR_TITLE, "The Track");
MediaItemAspect.SetAspect(aspects, aspect1);
MultipleMediaItemAspect aspect2 = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
aspect2.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\file.mp3");
MediaItemAspect.AddOrUpdateAspect(aspects, aspect2);
SingleMediaItemAspect aspect3 = new SingleMediaItemAspect(AudioAspect.Metadata);
MediaItemAspect.SetAspect(aspects, aspect3);
MediaItem item = new MediaItem(id, aspects);
objects.Add(MediaLibraryHelper.InstansiateMediaLibraryObject(item, null, null));
GenericDidlMessageBuilder builder = new GenericDidlMessageBuilder();
builder.BuildAll("*", objects);
string xml = builder.ToString();
Console.WriteLine("XML: {0}", xml);
}
private static void TransferTransientAspects(IDictionary <Guid, IList <MediaItemAspect> > aspects, IEnumerable <MediaItem> destinationMediaItems)
{
var transientAspects = MediaItemAspect.GetAspects(aspects).Where(mia => mia.Metadata.IsTransientAspect);
foreach (MediaItemAspect aspect in transientAspects)
{
SingleMediaItemAspect singleAspect = aspect as SingleMediaItemAspect;
if (singleAspect != null)
{
foreach (MediaItem destination in destinationMediaItems)
{
MediaItemAspect.SetAspect(destination.Aspects, singleAspect);
}
}
else
{
MultipleMediaItemAspect multiAspect = aspect as MultipleMediaItemAspect;
if (multiAspect != null)
{
foreach (MediaItem destination in destinationMediaItems)
{
MediaItemAspect.AddOrUpdateAspect(destination.Aspects, multiAspect);
}
}
}
}
}
public void TestExtractThumbnail()
{
// Arrange
string testFileName = "Test Media.mkv";
string testDataDir = TestContext.CurrentContext.TestDirectory + "\\VideoThumbnailer\\TestData\\";
ILocalFsResourceAccessor lfsra = new LocalFsResourceAccessor(new LocalFsResourceProvider(), "/" + Path.Combine(testDataDir, testFileName));
IDictionary <Guid, IList <MediaItemAspect> > aspects = new Dictionary <Guid, IList <MediaItemAspect> >();
MultipleMediaItemAspect videoStreamAspect = new MultipleMediaItemAspect(VideoStreamAspect.Metadata);
videoStreamAspect.SetAttribute(VideoStreamAspect.ATTR_RESOURCE_INDEX, 0);
videoStreamAspect.SetAttribute(VideoStreamAspect.ATTR_STREAM_INDEX, 1);
videoStreamAspect.SetAttribute(VideoStreamAspect.ATTR_DURATION, (long)1);
videoStreamAspect.SetAttribute(VideoStreamAspect.ATTR_WIDTH, 1076);
videoStreamAspect.SetAttribute(VideoStreamAspect.ATTR_HEIGHT, 1916);
MediaItemAspect.AddOrUpdateAspect(aspects, videoStreamAspect);
MultipleMediaItemAspect resourceAspect = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
resourceAspect.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_INDEX, 0);
resourceAspect.SetAttribute(ProviderResourceAspect.ATTR_TYPE, ProviderResourceAspect.TYPE_PRIMARY);
resourceAspect.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, lfsra.CanonicalLocalResourcePath.Serialize());
MediaItemAspect.AddOrUpdateAspect(aspects, resourceAspect);
// Act
bool success = new OCVVideoThumbnailer().TryExtractMetadataAsync(lfsra, aspects, false).Result;
// Assert
Assert.IsTrue(success);
Assert.IsTrue(aspects.ContainsKey(ThumbnailLargeAspect.ASPECT_ID));
}
public MockedDatabaseMovie(MediaLibraryMovie movie, int playPercentage)
{
IDictionary <Guid, IList <MediaItemAspect> > movieAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
MultipleMediaItemAspect resourceAspect = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
resourceAspect.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\" + movie.Title + ".mkv");
MediaItemAspect.AddOrUpdateAspect(movieAspects, resourceAspect);
MediaItemAspect.AddOrUpdateExternalIdentifier(movieAspects, ExternalIdentifierAspect.SOURCE_IMDB, ExternalIdentifierAspect.TYPE_MOVIE, movie.Imdb);
MediaItemAspect.SetAttribute(movieAspects, MovieAspect.ATTR_MOVIE_NAME, movie.Title);
SingleMediaItemAspect mediaItemAspect = new SingleMediaItemAspect(MediaAspect.Metadata);
mediaItemAspect.SetAttribute(MediaAspect.ATTR_PLAYCOUNT, 1);
mediaItemAspect.SetAttribute(MediaAspect.ATTR_LASTPLAYED, DateTime.Now);
MediaItemAspect.SetAspect(movieAspects, mediaItemAspect);
SingleMediaItemAspect importerAspect = new SingleMediaItemAspect(ImporterAspect.Metadata);
importerAspect.SetAttribute(ImporterAspect.ATTR_DATEADDED, DateTime.Now);
IDictionary <string, string> userData = new Dictionary <string, string>();
userData.Add(UserDataKeysKnown.KEY_PLAY_PERCENTAGE, playPercentage.ToString());
MediaItemAspect.SetAspect(movieAspects, importerAspect);
Movie = new MediaItem(Guid.NewGuid(), movieAspects, userData);
}
private void CopyAspects(MediaItem sourceMediaItem, MediaItem destinationMediaItem)
{
foreach (IList <MediaItemAspect> aspectList in sourceMediaItem.Aspects.Values.ToList())
{
foreach (MediaItemAspect aspectData in aspectList.ToList())
{
if (aspectData is SingleMediaItemAspect)
{
MediaItemAspect.SetAspect(destinationMediaItem.Aspects, (SingleMediaItemAspect)aspectData);
}
else if (aspectData is MultipleMediaItemAspect)
{
MediaItemAspect.AddOrUpdateAspect(destinationMediaItem.Aspects, (MultipleMediaItemAspect)aspectData);
}
}
}
}
public MockedDatabaseEpisode(string tvDbId, int seasonIndex, List <int> episodeIndex, int playPercentage)
{
IDictionary <Guid, IList <MediaItemAspect> > episodeAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
MultipleMediaItemAspect resourceAspect = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
resourceAspect.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\" + tvDbId + ".mkv");
MediaItemAspect.AddOrUpdateAspect(episodeAspects, resourceAspect);
MediaItemAspect.AddOrUpdateExternalIdentifier(episodeAspects, ExternalIdentifierAspect.SOURCE_TVDB, ExternalIdentifierAspect.TYPE_SERIES, tvDbId);
MediaItemAspect.SetAttribute(episodeAspects, EpisodeAspect.ATTR_SEASON, seasonIndex);
MediaItemAspect.SetCollectionAttribute(episodeAspects, EpisodeAspect.ATTR_EPISODE, episodeIndex);
SingleMediaItemAspect smia = new SingleMediaItemAspect(MediaAspect.Metadata);
MediaItemAspect.SetAspect(episodeAspects, smia);
IDictionary <string, string> userData = new Dictionary <string, string>();
userData.Add(UserDataKeysKnown.KEY_PLAY_PERCENTAGE, playPercentage.ToString());
Episode = new MediaItem(Guid.NewGuid(), episodeAspects, userData);
}
public MockedDatabaseMovie(string imdbId, string tmdbId, string title, int year, int playPercentage)
{
IDictionary <Guid, IList <MediaItemAspect> > movieAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
MultipleMediaItemAspect resourceAspect = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
resourceAspect.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\" + title + ".mkv");
MediaItemAspect.AddOrUpdateAspect(movieAspects, resourceAspect);
MediaItemAspect.AddOrUpdateExternalIdentifier(movieAspects, ExternalIdentifierAspect.SOURCE_IMDB, ExternalIdentifierAspect.TYPE_MOVIE, imdbId);
MediaItemAspect.AddOrUpdateExternalIdentifier(movieAspects, ExternalIdentifierAspect.SOURCE_TMDB, ExternalIdentifierAspect.TYPE_MOVIE, tmdbId);
MediaItemAspect.SetAttribute(movieAspects, MovieAspect.ATTR_MOVIE_NAME, title);
SingleMediaItemAspect smia = new SingleMediaItemAspect(MediaAspect.Metadata);
smia.SetAttribute(MediaAspect.ATTR_RECORDINGTIME, new DateTime(year, 1, 1));
MediaItemAspect.SetAspect(movieAspects, smia);
IDictionary <string, string> userData = new Dictionary <string, string>();
userData.Add(UserDataKeysKnown.KEY_PLAY_PERCENTAGE, playPercentage.ToString());
Movie = new MediaItem(Guid.NewGuid(), movieAspects, userData);
}
public void TestAudioItem()
{
IList <IDirectoryObject> objects = new List <IDirectoryObject>();
BasicContainer root = new BasicContainer("TEST", new EndPointSettings
{
PreferredSubtitleLanguages = new string[] { "EN" },
PreferredAudioLanguages = new string[] { "EN" },
Profile = new EndPointProfile()
});
Guid id = new Guid("11111111-aaaa-aaaa-aaaa-111111111111");
IDictionary <Guid, IList <MediaItemAspect> > aspects = new Dictionary <Guid, IList <MediaItemAspect> >();
SingleMediaItemAspect aspect1 = new SingleMediaItemAspect(MediaAspect.Metadata);
aspect1.SetAttribute(MediaAspect.ATTR_TITLE, "The Track");
MediaItemAspect.SetAspect(aspects, aspect1);
MultipleMediaItemAspect aspect2 = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
aspect2.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\file.mp3");
MediaItemAspect.AddOrUpdateAspect(aspects, aspect2);
SingleMediaItemAspect aspect3 = new SingleMediaItemAspect(AudioAspect.Metadata);
MediaItemAspect.SetAspect(aspects, aspect3);
MediaItem item = new MediaItem(id, aspects);
objects.Add(MediaLibraryHelper.InstansiateMediaLibraryObject(item, root, "Test"));
GenericDidlMessageBuilder builder = new GenericDidlMessageBuilder();
builder.BuildAll("*", objects);
string xml = builder.ToString();
Console.WriteLine("XML: {0}", xml);
}
public MockedDatabaseMovie(MediaLibraryMovie movie)
{
IDictionary <Guid, IList <MediaItemAspect> > movieAspects = new Dictionary <Guid, IList <MediaItemAspect> >();
MultipleMediaItemAspect resourceAspect = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
resourceAspect.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\" + movie.Title + ".mkv");
MediaItemAspect.AddOrUpdateAspect(movieAspects, resourceAspect);
MediaItemAspect.AddOrUpdateExternalIdentifier(movieAspects, ExternalIdentifierAspect.SOURCE_IMDB, ExternalIdentifierAspect.TYPE_MOVIE, movie.Imdb);
MediaItemAspect.SetAttribute(movieAspects, MovieAspect.ATTR_MOVIE_NAME, movie.Title);
SingleMediaItemAspect mediaItemAspect = new SingleMediaItemAspect(MediaAspect.Metadata);
mediaItemAspect.SetAttribute(MediaAspect.ATTR_PLAYCOUNT, movie.PlayCount);
mediaItemAspect.SetAttribute(MediaAspect.ATTR_LASTPLAYED, DateTime.Parse(movie.LastPlayed));
MediaItemAspect.SetAspect(movieAspects, mediaItemAspect);
SingleMediaItemAspect importerAspect = new SingleMediaItemAspect(ImporterAspect.Metadata);
importerAspect.SetAttribute(ImporterAspect.ATTR_DATEADDED, DateTime.Parse(movie.AddedToDb));
MediaItemAspect.SetAspect(movieAspects, importerAspect);
Movie = new MediaItem(Guid.NewGuid(), movieAspects);
}
public void TestComplexItem()
{
Guid trackId = new Guid("11111111-aaaa-aaaa-aaaa-100000000000");
Guid albumId = new Guid("11111111-aaaa-aaaa-aaaa-100000000001");
Guid artistId = new Guid("11111111-aaaa-aaaa-aaaa-100000000002");
Guid trackRelationship = new Guid("22222222-bbbb-bbbb-bbbb-200000000001");
Guid albumRelationship = new Guid("33333333-cccc-cccc-cccc-300000000001");
Guid artistRelationship = new Guid("44444444-dddd-dddd-dddd-400000000001");
IDictionary <Guid, IList <MediaItemAspect> > aspects1 = new Dictionary <Guid, IList <MediaItemAspect> >();
MultipleMediaItemAspect resourceAspect1 = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
resourceAspect1.Deleted = true;
resourceAspect1.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\file.mp3");
MediaItemAspect.AddOrUpdateAspect(aspects1, resourceAspect1);
MediaItemAspect.AddOrUpdateRelationship(aspects1, trackRelationship, albumRelationship, albumId, 1);
MediaItemAspect.AddOrUpdateRelationship(aspects1, trackRelationship, artistRelationship, artistId, 0);
MediaItem track1 = new MediaItem(trackId, aspects1);
TextWriter writer = new StringWriter();
XmlWriter serialiser = new XmlTextWriter(writer);
serialiser.WriteStartElement("Test"); // Wrapper around the tracks
// Write the track twice
track1.Serialize(serialiser);
track1.Serialize(serialiser);
serialiser.WriteEndElement();
//Console.WriteLine("XML: {0}", writer.ToString());
//Assert.AreEqual("<MI Id=\"" + trackId + "\"><Relationship ItemType=\"" + AudioAspect.RELATIONSHIP_TRACK + "\" RelationshipType=\"" + AlbumAspect.RELATIONSHIP_ALBUM + "\" RelationshipId=\"" + albumId + "\" /></MI>", trackText.ToString(), "Track XML");
XmlReader reader = XmlReader.Create(new StringReader(writer.ToString()));
reader.Read(); // Test
//Console.WriteLine("Reader state Test, {0} {1}", reader.NodeType, reader.Name);
// Read the track once
reader.Read(); // MI
//Console.WriteLine("Reader state track2, {0} {1}", reader.NodeType, reader.Name);
MediaItem track2 = MediaItem.Deserialize(reader);
IList <MultipleMediaItemAspect> resourceAspect2;
Assert.IsTrue(MediaItemAspect.TryGetAspects(track2.Aspects, ProviderResourceAspect.Metadata, out resourceAspect2), "Resource aspects");
Assert.AreEqual(true, resourceAspect2[0].Deleted, "Track deleted status");
Assert.AreEqual("c:\\file.mp3", resourceAspect2[0].GetAttributeValue <string>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH), "Track location");
IList <MediaItemAspect> relationships2 = track2[RelationshipAspect.ASPECT_ID];
Assert.IsTrue(track2[RelationshipAspect.ASPECT_ID] != null, "Relationship aspects");
Assert.AreEqual(relationships2.Count, 2, "Track relationship count");
Assert.AreEqual(trackRelationship, relationships2[0].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(albumRelationship, relationships2[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(albumId, relationships2[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
Assert.AreEqual(trackRelationship, relationships2[1].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(artistRelationship, relationships2[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(artistId, relationships2[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
// Read the track a second time (
//Console.WriteLine("Reader state track3, {0} {1}", reader.NodeType, reader.Name);
MediaItem track3 = MediaItem.Deserialize(reader);
IList <MultipleMediaItemAspect> resourceAspect3;
Assert.IsTrue(MediaItemAspect.TryGetAspects(track3.Aspects, ProviderResourceAspect.Metadata, out resourceAspect3), "Resource aspects");
Assert.AreEqual("c:\\file.mp3", resourceAspect3[0].GetAttributeValue <string>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH), "Track location");
IList <MediaItemAspect> relationships3 = track3[RelationshipAspect.ASPECT_ID];
Assert.IsTrue(track3[RelationshipAspect.ASPECT_ID] != null, "Relationship aspects");
Assert.AreEqual(2, relationships3.Count, "Track relationship count");
Assert.AreEqual(trackRelationship, relationships3[0].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(albumRelationship, relationships3[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(albumId, relationships3[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
Assert.AreEqual(trackRelationship, relationships3[1].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(artistRelationship, relationships3[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(artistId, relationships3[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
reader.Read(); // Test
}
public void TestRelationshipSerialization()
{
IDictionary <Guid, IList <MediaItemAspect> > aspects1 = new Dictionary <Guid, IList <MediaItemAspect> >();
Guid trackId = new Guid("11111111-aaaa-aaaa-aaaa-100000000000");
Guid albumId = new Guid("11111111-aaaa-aaaa-aaaa-100000000001");
Guid artistId = new Guid("11111111-aaaa-aaaa-aaaa-100000000002");
Guid trackRelationship = new Guid("22222222-bbbb-bbbb-bbbb-200000000001");
Guid albumRelationship = new Guid("33333333-cccc-cccc-cccc-300000000001");
Guid artistRelationship = new Guid("44444444-dddd-dddd-dddd-400000000001");
MediaItemAspect.AddOrUpdateRelationship(aspects1, trackRelationship, albumRelationship, albumId, true, 1);
MediaItemAspect.AddOrUpdateRelationship(aspects1, trackRelationship, artistRelationship, artistId, false, 0);
MultipleMediaItemAspect resourceAspect1 = new MultipleMediaItemAspect(ProviderResourceAspect.Metadata);
resourceAspect1.Deleted = true;
resourceAspect1.SetAttribute(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH, "c:\\file.mp3");
MediaItemAspect.AddOrUpdateAspect(aspects1, resourceAspect1);
Guid role1 = new Guid("55555555-eeee-eeee-eeee-500000000001");
Guid linkedRole1 = new Guid("66666666-ffff-ffff-ffff-600000000001");
RelationshipItem relationship1 = new RelationshipItem(role1, linkedRole1, aspects1);
TextWriter writer = new StringWriter();
XmlWriter serialiser = new XmlTextWriter(writer);
serialiser.WriteStartElement("Test"); // Wrapper around the relationships
// Write the relationship twice
relationship1.Serialize(serialiser);
relationship1.Serialize(serialiser);
serialiser.WriteEndElement();
XmlReader reader = XmlReader.Create(new StringReader(writer.ToString()));
reader.Read(); // Test
// Read the relationship once
reader.Read(); // RI
RelationshipItem relationship2 = RelationshipItem.Deserialize(reader);
Assert.AreEqual(relationship2.Role, role1, "Role");
Assert.AreEqual(relationship2.LinkedRole, linkedRole1, "Linked role");
IList <MultipleMediaItemAspect> resourceAspect2;
Assert.IsTrue(MediaItemAspect.TryGetAspects(relationship2.Aspects, ProviderResourceAspect.Metadata, out resourceAspect2), "Resource aspects");
Assert.AreEqual(true, resourceAspect2[0].Deleted, "Track deleted status");
Assert.AreEqual("c:\\file.mp3", resourceAspect2[0].GetAttributeValue <string>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH), "Track location");
IList <MediaItemAspect> relationships2 = relationship2.Aspects[RelationshipAspect.ASPECT_ID];
Assert.IsTrue(relationship2.Aspects[RelationshipAspect.ASPECT_ID] != null, "Relationship aspects");
Assert.AreEqual(relationships2.Count, 2, "Track relationship count");
Assert.AreEqual(trackRelationship, relationships2[0].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(albumRelationship, relationships2[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(albumId, relationships2[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
Assert.AreEqual(trackRelationship, relationships2[1].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(artistRelationship, relationships2[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(artistId, relationships2[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
// Read the relationship a second time
RelationshipItem relationship3 = RelationshipItem.Deserialize(reader);
Assert.AreEqual(relationship3.Role, relationship2.Role, "Role");
Assert.AreEqual(relationship3.LinkedRole, relationship2.LinkedRole, "Linked role");
IList <MultipleMediaItemAspect> resourceAspect3;
Assert.IsTrue(MediaItemAspect.TryGetAspects(relationship3.Aspects, ProviderResourceAspect.Metadata, out resourceAspect3), "Resource aspects");
Assert.AreEqual("c:\\file.mp3", resourceAspect3[0].GetAttributeValue <string>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH), "Track location");
IList <MediaItemAspect> relationships3 = relationship3.Aspects[RelationshipAspect.ASPECT_ID];
Assert.IsTrue(relationship3.Aspects[RelationshipAspect.ASPECT_ID] != null, "Relationship aspects");
Assert.AreEqual(2, relationships3.Count, "Track relationship count");
Assert.AreEqual(trackRelationship, relationships3[0].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(albumRelationship, relationships3[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(albumId, relationships3[0].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
Assert.AreEqual(trackRelationship, relationships3[1].GetAttributeValue(RelationshipAspect.ATTR_ROLE), "Track -> album item type");
Assert.AreEqual(artistRelationship, relationships3[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ROLE), "Track -> album relationship type");
Assert.AreEqual(artistId, relationships3[1].GetAttributeValue(RelationshipAspect.ATTR_LINKED_ID), "Track -> album relationship ID");
reader.Read(); // Test
}
public IList <MediaItem> Query(ISQLDatabase database, ITransaction transaction, bool singleMode)
{
ILogger logger = ServiceRegistration.Get <ILogger>();
try
{
IList <MediaItemAspectMetadata> selectedMIAs = new List <MediaItemAspectMetadata>(_necessaryRequestedMIAs.Union(_optionalRequestedMIAs));
IList <Guid> mediaItemIds;
IDictionary <Guid, IList <Guid> > complexMediaItemIds;
IList <MediaItem> mediaItems = GetMediaItems(database, transaction, singleMode, selectedMIAs, out mediaItemIds, out complexMediaItemIds);
//logger.Debug("CompiledMediaItemQuery::Query got media items IDs [{0}]", string.Join(",", mediaItemIds));
// TODO: Why bother looking for complex attributes on MIAs we don't have?
IDictionary <Guid, IDictionary <MediaItemAspectMetadata.AttributeSpecification, IList> > complexAttributeValues =
new Dictionary <Guid, IDictionary <MediaItemAspectMetadata.AttributeSpecification, IList> >();
ICollection <IList <Guid> > mediaItemIdsClusters = CollectionUtils.Cluster(mediaItemIds, CompiledFilter.MAX_IN_VALUES_SIZE);
foreach (IList <Guid> mediaItemIdsCluster in mediaItemIdsClusters.Where(x => x.Count > 0))
{
AddComplexAttributes(database, transaction, mediaItemIdsCluster, complexAttributeValues, complexMediaItemIds);
}
foreach (MediaItem mediaItem in mediaItems)
{
foreach (SingleMediaItemAspectMetadata miam in selectedMIAs.Where(x => x is SingleMediaItemAspectMetadata))
{
// Skip complex attributes for this MIA if it's not already in the media item
if (!mediaItem.Aspects.ContainsKey(miam.AspectId))
{
continue;
}
IDictionary <MediaItemAspectMetadata.AttributeSpecification, IList> attributeValues;
if (!complexAttributeValues.TryGetValue(mediaItem.MediaItemId, out attributeValues))
{
continue;
}
SingleMediaItemAspect mia = MediaItemAspect.GetOrCreateAspect(mediaItem.Aspects, miam);
foreach (MediaItemAspectMetadata.AttributeSpecification attr in miam.AttributeSpecifications.Values)
{
if (attr.Cardinality != Cardinality.Inline)
{
IList attrValues;
if (attributeValues != null && attributeValues.TryGetValue(attr, out attrValues))
{
mia.SetCollectionAttribute(attr, attrValues);
}
}
}
}
}
IDictionary <Guid, ICollection <MultipleMediaItemAspect> > multipleMiaValues =
new Dictionary <Guid, ICollection <MultipleMediaItemAspect> >();
foreach (IList <Guid> mediaItemIdsCluster in mediaItemIdsClusters.Where(x => x.Count > 0))
{
AddMultipleMIAs(database, transaction, _explicitRequestedMIAs, mediaItemIdsCluster, multipleMiaValues);
}
if (multipleMiaValues.Count > 0)
{
//logger.Debug("Got multiple MIAs [{0}]", string.Join(",", multipleMiaValues.Keys));
foreach (MediaItem mediaItem in mediaItems)
{
ICollection <MultipleMediaItemAspect> values;
if (!multipleMiaValues.TryGetValue(mediaItem.MediaItemId, out values))
{
continue;
}
foreach (MultipleMediaItemAspect value in values)
{
//logger.Debug("Adding MIA {0} #{1}", value.Metadata.Name, value.Index);
MediaItemAspect.AddOrUpdateAspect(mediaItem.Aspects, value);
}
}
}
return(mediaItems);
}
catch (Exception e)
{
logger.Error("Unable to query", e);
throw e;
}
}