public void GetVideosWithFile_WithNoVideos()
{
var fileRepository = new MediaFileRepository();
var fileId = fileRepository.CreateMediaFile(new CreateMediaFileDto("", MediaFileType.VIDEO_TYPE, ""));
var expectedList = new List <Video> {
};
var actualList = repository.GetVideosWithFile(GetFirstPage(), fileId).Result.Results;
CollectionAssert.AreEquivalent(expectedList, actualList);
}
private void InitRepositories()
{
libraryRepository = DependencyInjectionContainer.Container.Resolve <LibraryRepository>();
videoRepository = DependencyInjectionContainer.Container.Resolve <VideoRepository>();
characterRepository = DependencyInjectionContainer.Container.Resolve <CharacterRepository>();
seriesRepository = DependencyInjectionContainer.Container.Resolve <SeriesRepository>();
publisherRepository = DependencyInjectionContainer.Container.Resolve <PublisherRepository>();
calendarRepository = DependencyInjectionContainer.Container.Resolve <CalendarRepository>();
locationRepository = DependencyInjectionContainer.Container.Resolve <LocationRepository>();
playlistRepository = DependencyInjectionContainer.Container.Resolve <PlaylistRepository>();
tagRepository = DependencyInjectionContainer.Container.Resolve <TagRepository>();
mediaFileRepository = DependencyInjectionContainer.Container.Resolve <MediaFileRepository>();
seriesSequenceRepository = DependencyInjectionContainer.Container.Resolve <SeriesSequenceRepository>();
}
public void TestCreateLocation_WithCover()
{
var tagName = "Test name";
var description = "Test tag";
var coverFileId = new MediaFileRepository().CreateMediaFile(new CreateMediaFileDto("C:/test.jpg", MediaFileType.IMAGE_TYPE, "test"));
var locationId = repository.CreateLocation(new CreateLocationDto(tagName, description, testLibrary.LibraryId, DatabaseConstants.DEFAULT_ID, coverFileId));
var location = repository.GetLocation(locationId);
Assert.AreEqual(tagName, location.Name);
Assert.AreEqual(description, location.Description);
Assert.AreEqual(locationId, location.LocationId);
Assert.AreEqual(testLibrary.LibraryId, location.LibraryId);
Assert.AreEqual(DatabaseConstants.DEFAULT_ID, location.PublisherId);
Assert.AreEqual(coverFileId, location.CoverFileId);
}
public void GetVideosWithFile_WithOtherFileOnVideos()
{
var fileRepository = new MediaFileRepository();
var fileId = fileRepository.CreateMediaFile(new CreateMediaFileDto("", MediaFileType.VIDEO_TYPE, ""));
var file2Id = fileRepository.CreateMediaFile(new CreateMediaFileDto("", MediaFileType.VIDEO_TYPE, ""));
var file2 = fileRepository.GetMediaFile(file2Id);
var videoDto = GetNewVideoDetails();
var video1Id = repository.CreateVideo(videoDto);
fileRepository.AddFileToVideo(video1Id, file2).ConfigureAwait(false);
var expectedList = new List <Video> {
};
var actualList = repository.GetVideosWithFile(GetFirstPage(), fileId).Result.Results;
CollectionAssert.AreEquivalent(expectedList, actualList);
}
public void should_explicit_load_everything_if_joined()
{
var db = Mocker.Resolve <IDatabase>();
var files = MediaFileRepository.Query(db,
new SqlBuilder()
.Join <BookFile, Edition>((t, a) => t.EditionId == a.Id)
.Join <Edition, Book>((e, b) => e.BookId == b.Id)
.Join <Book, Author>((book, author) => book.AuthorMetadataId == author.AuthorMetadataId)
.Join <Author, AuthorMetadata>((a, m) => a.AuthorMetadataId == m.Id));
Assert.IsNotEmpty(files);
foreach (var file in files)
{
Assert.IsTrue(file.Edition.IsLoaded);
Assert.IsTrue(file.Author.IsLoaded);
Assert.IsTrue(file.Author.Value.Metadata.IsLoaded);
}
}
public void should_explicit_load_everything_if_joined()
{
var db = Mocker.Resolve <IDatabase>();
var files = MediaFileRepository.Query(db,
new SqlBuilder()
.Join <TrackFile, Track>((f, t) => f.Id == t.TrackFileId)
.Join <TrackFile, Album>((t, a) => t.AlbumId == a.Id)
.Join <Album, Artist>((album, artist) => album.ArtistMetadataId == artist.ArtistMetadataId)
.Join <Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id));
Assert.IsNotEmpty(files);
foreach (var file in files)
{
Assert.IsTrue(file.Tracks.IsLoaded);
Assert.IsNotEmpty(file.Tracks.Value);
Assert.IsTrue(file.Album.IsLoaded);
Assert.IsTrue(file.Artist.IsLoaded);
Assert.IsTrue(file.Artist.Value.Metadata.IsLoaded);
}
}
public void GetVideosWithFile_WithFileAttachedToVideo_AndCover_ShouldntReturnDuplicates()
{
var fileRepository = new MediaFileRepository();
var fileId = fileRepository.CreateMediaFile(new CreateMediaFileDto("", MediaFileType.VIDEO_TYPE, ""));
var file = fileRepository.GetMediaFile(fileId);
var videoDto = GetNewVideoDetails();
videoDto.CoverFileId = fileId;
var video1Id = repository.CreateVideo(videoDto);
var video1 = repository.GetVideo(video1Id).Result;
fileRepository.AddFileToVideo(video1Id, file).ConfigureAwait(false);
var expectedList = new List <Video> {
video1
};
var actualList = repository.GetVideosWithFile(GetFirstPage(), fileId).Result.Results;
CollectionAssert.AreEquivalent(expectedList, actualList);
}
/// <summary>
/// Creates an instance of <see cref="CardWidgetViewComponent"/> class.
/// </summary>
/// <param name="mediaFileRepository">Repository for media files.</param>
/// <param name="mediaFileUrlRetriever">The media file URL retriever.</param>
public CardWidgetViewComponent(MediaFileRepository mediaFileRepository, IMediaFileUrlRetriever mediaFileUrlRetriever)
{
this.mediaFileRepository = mediaFileRepository;
this.mediaFileUrlRetriever = mediaFileUrlRetriever;
}
public static void Map()
{
RegisterMappers();
Mapper.Entity <Config>("Config").RegisterModel();
Mapper.Entity <RootFolder>("RootFolders").RegisterModel()
.Ignore(r => r.Accessible)
.Ignore(r => r.FreeSpace)
.Ignore(r => r.TotalSpace);
Mapper.Entity <ScheduledTask>("ScheduledTasks").RegisterModel();
Mapper.Entity <IndexerDefinition>("Indexers").RegisterModel()
.Ignore(x => x.ImplementationName)
.Ignore(i => i.Enable)
.Ignore(i => i.Protocol)
.Ignore(i => i.SupportsRss)
.Ignore(i => i.SupportsSearch)
.Ignore(d => d.Tags);
Mapper.Entity <ImportListDefinition>("ImportLists").RegisterModel()
.Ignore(x => x.ImplementationName)
.Ignore(i => i.Enable)
.Ignore(i => i.ListType);
Mapper.Entity <NotificationDefinition>("Notifications").RegisterModel()
.Ignore(x => x.ImplementationName)
.Ignore(i => i.SupportsOnGrab)
.Ignore(i => i.SupportsOnReleaseImport)
.Ignore(i => i.SupportsOnUpgrade)
.Ignore(i => i.SupportsOnRename)
.Ignore(i => i.SupportsOnHealthIssue)
.Ignore(i => i.SupportsOnDownloadFailure)
.Ignore(i => i.SupportsOnImportFailure)
.Ignore(i => i.SupportsOnTrackRetag);
Mapper.Entity <MetadataDefinition>("Metadata").RegisterModel()
.Ignore(x => x.ImplementationName)
.Ignore(d => d.Tags);
Mapper.Entity <DownloadClientDefinition>("DownloadClients").RegisterModel()
.Ignore(x => x.ImplementationName)
.Ignore(d => d.Protocol)
.Ignore(d => d.Tags);
Mapper.Entity <History.History>("History").RegisterModel();
Mapper.Entity <Artist>("Artists")
.Ignore(s => s.RootFolderPath)
.Ignore(s => s.Name)
.Ignore(s => s.ForeignArtistId)
.HasOne(a => a.Metadata, a => a.ArtistMetadataId)
.HasOne(a => a.QualityProfile, a => a.QualityProfileId)
.HasOne(s => s.MetadataProfile, s => s.MetadataProfileId)
.LazyLoad(a => a.Albums, (db, a) => db.Query <Album>(new SqlBuilder().Where <Album>(rg => rg.ArtistMetadataId == a.Id)).ToList(), a => a.Id > 0);
Mapper.Entity <ArtistMetadata>("ArtistMetadata").RegisterModel();
Mapper.Entity <Album>("Albums").RegisterModel()
.Ignore(x => x.ArtistId)
.HasOne(r => r.ArtistMetadata, r => r.ArtistMetadataId)
.LazyLoad(a => a.AlbumReleases, (db, album) => db.Query <AlbumRelease>(new SqlBuilder().Where <AlbumRelease>(r => r.AlbumId == album.Id)).ToList(), a => a.Id > 0)
.LazyLoad(a => a.Artist,
(db, album) => ArtistRepository.Query(db,
new SqlBuilder()
.Join <Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Where <Artist>(a => a.ArtistMetadataId == album.ArtistMetadataId)).SingleOrDefault(),
a => a.ArtistMetadataId > 0);
Mapper.Entity <AlbumRelease>("AlbumReleases").RegisterModel()
.HasOne(r => r.Album, r => r.AlbumId)
.LazyLoad(x => x.Tracks, (db, release) => db.Query <Track>(new SqlBuilder().Where <Track>(t => t.AlbumReleaseId == release.Id)).ToList(), r => r.Id > 0);
Mapper.Entity <Track>("Tracks").RegisterModel()
.Ignore(t => t.HasFile)
.Ignore(t => t.AlbumId)
.HasOne(track => track.AlbumRelease, track => track.AlbumReleaseId)
.HasOne(track => track.ArtistMetadata, track => track.ArtistMetadataId)
.LazyLoad(t => t.TrackFile,
(db, track) => MediaFileRepository.Query(db,
new SqlBuilder()
.Join <TrackFile, Track>((l, r) => l.Id == r.TrackFileId)
.Join <TrackFile, Album>((l, r) => l.AlbumId == r.Id)
.Join <Album, Artist>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Join <Artist, ArtistMetadata>((l, r) => l.ArtistMetadataId == r.Id)
.Where <TrackFile>(t => t.Id == track.TrackFileId)).SingleOrDefault(),
t => t.TrackFileId > 0)
.LazyLoad(x => x.Artist,
(db, t) => ArtistRepository.Query(db,
new SqlBuilder()
.Join <Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Join <Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Join <Album, AlbumRelease>((l, r) => l.Id == r.AlbumId)
.Where <AlbumRelease>(r => r.Id == t.AlbumReleaseId)).SingleOrDefault(),
t => t.Id > 0);
Mapper.Entity <TrackFile>("TrackFiles").RegisterModel()
.HasOne(f => f.Album, f => f.AlbumId)
.LazyLoad(x => x.Tracks, (db, file) => db.Query <Track>(new SqlBuilder().Where <Track>(t => t.TrackFileId == file.Id)).ToList(), x => x.Id > 0)
.LazyLoad(x => x.Artist,
(db, f) => ArtistRepository.Query(db,
new SqlBuilder()
.Join <Artist, ArtistMetadata>((a, m) => a.ArtistMetadataId == m.Id)
.Join <Artist, Album>((l, r) => l.ArtistMetadataId == r.ArtistMetadataId)
.Where <Album>(a => a.Id == f.AlbumId)).SingleOrDefault(),
t => t.Id > 0);
Mapper.Entity <QualityDefinition>("QualityDefinitions").RegisterModel()
.Ignore(d => d.GroupName)
.Ignore(d => d.GroupWeight)
.Ignore(d => d.Weight);
Mapper.Entity <QualityProfile>("QualityProfiles").RegisterModel();
Mapper.Entity <MetadataProfile>("MetadataProfiles").RegisterModel();
Mapper.Entity <Log>("Logs").RegisterModel();
Mapper.Entity <NamingConfig>("NamingConfig").RegisterModel();
Mapper.Entity <Blacklist>("Blacklist").RegisterModel();
Mapper.Entity <MetadataFile>("MetadataFiles").RegisterModel();
Mapper.Entity <LyricFile>("LyricFiles").RegisterModel();
Mapper.Entity <OtherExtraFile>("ExtraFiles").RegisterModel();
Mapper.Entity <PendingRelease>("PendingReleases").RegisterModel()
.Ignore(e => e.RemoteAlbum);
Mapper.Entity <RemotePathMapping>("RemotePathMappings").RegisterModel();
Mapper.Entity <Tag>("Tags").RegisterModel();
Mapper.Entity <ReleaseProfile>("ReleaseProfiles").RegisterModel();
Mapper.Entity <DelayProfile>("DelayProfiles").RegisterModel();
Mapper.Entity <User>("Users").RegisterModel();
Mapper.Entity <CommandModel>("Commands").RegisterModel()
.Ignore(c => c.Message);
Mapper.Entity <IndexerStatus>("IndexerStatus").RegisterModel();
Mapper.Entity <DownloadClientStatus>("DownloadClientStatus").RegisterModel();
Mapper.Entity <ImportListStatus>("ImportListStatus").RegisterModel();
Mapper.Entity <CustomFilter>("CustomFilters").RegisterModel();
Mapper.Entity <ImportListExclusion>("ImportListExclusions").RegisterModel();
}
public void Setup()
{
var profile = new Profile
{
Id = 1,
Cutoff = Quality.WEBDL480p,
Items = new List <ProfileQualityItem>
{
new ProfileQualityItem {
Allowed = true, Quality = Quality.SDTV
},
new ProfileQualityItem {
Allowed = true, Quality = Quality.WEBDL480p
},
new ProfileQualityItem {
Allowed = true, Quality = Quality.RAWHD
}
}
};
_monitoredSeries = Builder <Series> .CreateNew()
.With(s => s.TvRageId = RandomNumber)
.With(s => s.Runtime = 30)
.With(s => s.Monitored = true)
.With(s => s.TitleSlug = "Title3")
.With(s => s.Id = profile.Id)
.BuildNew();
_unmonitoredSeries = Builder <Series> .CreateNew()
.With(s => s.TvdbId = RandomNumber)
.With(s => s.Runtime = 30)
.With(s => s.Monitored = false)
.With(s => s.TitleSlug = "Title2")
.With(s => s.Id = profile.Id)
.BuildNew();
_monitoredSeries.Id = Db.Insert(_monitoredSeries).Id;
_unmonitoredSeries.Id = Db.Insert(_unmonitoredSeries).Id;
_pagingSpec = new PagingSpec <Episode>
{
Page = 1,
PageSize = 10,
SortKey = "AirDate",
SortDirection = SortDirection.Ascending
};
_qualitiesBelowCutoff = new List <QualitiesBelowCutoff>
{
new QualitiesBelowCutoff(profile.Id, new[] { Quality.SDTV.Id })
};
var qualityMet = new EpisodeFile {
RelativePath = "a", Quality = new QualityModel {
Quality = Quality.WEBDL480p
}
};
var qualityUnmet = new EpisodeFile {
RelativePath = "b", Quality = new QualityModel {
Quality = Quality.SDTV
}
};
var qualityRawHD = new EpisodeFile {
RelativePath = "c", Quality = new QualityModel {
Quality = Quality.RAWHD
}
};
MediaFileRepository fileRepository = Mocker.Resolve <MediaFileRepository>();
qualityMet = fileRepository.Insert(qualityMet);
qualityUnmet = fileRepository.Insert(qualityUnmet);
qualityRawHD = fileRepository.Insert(qualityRawHD);
var monitoredSeriesEpisodes = Builder <Episode> .CreateListOfSize(4)
.All()
.With(e => e.Id = 0)
.With(e => e.SeriesId = _monitoredSeries.Id)
.With(e => e.AirDateUtc = DateTime.Now.AddDays(-5))
.With(e => e.Monitored = true)
.With(e => e.EpisodeFileId = qualityUnmet.Id)
.TheFirst(1)
.With(e => e.Monitored = false)
.With(e => e.EpisodeFileId = qualityMet.Id)
.TheNext(1)
.With(e => e.EpisodeFileId = qualityRawHD.Id)
.TheLast(1)
.With(e => e.SeasonNumber = 0)
.Build();
var unmonitoredSeriesEpisodes = Builder <Episode> .CreateListOfSize(3)
.All()
.With(e => e.Id = 0)
.With(e => e.SeriesId = _unmonitoredSeries.Id)
.With(e => e.AirDateUtc = DateTime.Now.AddDays(-5))
.With(e => e.Monitored = true)
.With(e => e.EpisodeFileId = qualityUnmet.Id)
.TheFirst(1)
.With(e => e.Monitored = false)
.With(e => e.EpisodeFileId = qualityMet.Id)
.TheLast(1)
.With(e => e.SeasonNumber = 0)
.Build();
_unairedEpisodes = Builder <Episode> .CreateListOfSize(1)
.All()
.With(e => e.Id = 0)
.With(e => e.SeriesId = _monitoredSeries.Id)
.With(e => e.AirDateUtc = DateTime.Now.AddDays(5))
.With(e => e.Monitored = true)
.With(e => e.EpisodeFileId = qualityUnmet.Id)
.Build()
.ToList();
Db.InsertMany(monitoredSeriesEpisodes);
Db.InsertMany(unmonitoredSeriesEpisodes);
}
public MediaGalleryViewComponent(MediaFileRepository mediaFileRepository, IMediaFileUrlRetriever fileUrlRetriever)
{
this.mediaFileRepository = mediaFileRepository;
this.fileUrlRetriever = fileUrlRetriever;
}
