コード例 #1
0
        public AlbumForApiContract(
            Album album, AlbumMergeRecord mergeRecord,
            ContentLanguagePreference languagePreference,
            IEntryThumbPersister thumbPersister,
            bool ssl,
            AlbumOptionalFields fields) : this(album, mergeRecord, languagePreference,
                                               fields.HasFlag(AlbumOptionalFields.Artists),
                                               fields.HasFlag(AlbumOptionalFields.Names),
                                               fields.HasFlag(AlbumOptionalFields.PVs),
                                               fields.HasFlag(AlbumOptionalFields.Tags),
                                               fields.HasFlag(AlbumOptionalFields.WebLinks))
        {
            if (languagePreference != ContentLanguagePreference.Default || fields.HasFlag(AlbumOptionalFields.AdditionalNames))
            {
                AdditionalNames = album.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            }

            if (fields.HasFlag(AlbumOptionalFields.Identifiers))
            {
                Identifiers = album.Identifiers.Select(i => new AlbumIdentifierContract(i)).ToArray();
            }

            if (thumbPersister != null && fields.HasFlag(AlbumOptionalFields.MainPicture) && !string.IsNullOrEmpty(album.CoverPictureMime))
            {
                MainPicture = new EntryThumbForApiContract(new EntryThumb(album, album.CoverPictureMime), thumbPersister, ssl);
            }
        }
コード例 #2
0
		public AlbumForApiContract(
			Album album, AlbumMergeRecord mergeRecord, 
			ContentLanguagePreference languagePreference, 
			IEntryThumbPersister thumbPersister,
			bool ssl,
			AlbumOptionalFields fields) : this(album, mergeRecord, languagePreference, 
				fields.HasFlag(AlbumOptionalFields.Artists), 
				fields.HasFlag(AlbumOptionalFields.Names), 
				fields.HasFlag(AlbumOptionalFields.PVs), 
				fields.HasFlag(AlbumOptionalFields.Tags), 
				fields.HasFlag(AlbumOptionalFields.WebLinks)) {

			if (languagePreference != ContentLanguagePreference.Default || fields.HasFlag(AlbumOptionalFields.AdditionalNames)) {
				AdditionalNames = album.Names.GetAdditionalNamesStringForLanguage(languagePreference);
			}

			if (fields.HasFlag(AlbumOptionalFields.Identifiers)) {
				Identifiers = album.Identifiers.Select(i => new AlbumIdentifierContract(i)).ToArray();
			}

			if (thumbPersister != null && fields.HasFlag(AlbumOptionalFields.MainPicture) && !string.IsNullOrEmpty(album.CoverPictureMime)) {
				
				MainPicture = new EntryThumbForApiContract(new EntryThumb(album, album.CoverPictureMime), thumbPersister, ssl);

			}

		}
コード例 #3
0
ファイル: AlbumApiController.cs プロジェクト: sethura/vocadb
        public AlbumForApiContract GetOne(int id, AlbumOptionalFields fields = AlbumOptionalFields.None, ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            var ssl   = WebHelper.IsSSL(Request);
            var album = service.GetAlbumWithMergeRecord(id, (a, m) => new AlbumForApiContract(a, m, lang, thumbPersister, ssl, fields));

            return(album);
        }
コード例 #4
0
        public PartialFindResult <AlbumForUserForApiContract> GetAlbumCollection(
            int userId,
            string query = "",
            string tag   = null,
            int?artistId = null,
            [FromUri] PurchaseStatuses?purchaseStatuses = null,
            string releaseEventName = null,
            int start                      = 0,
            int maxResults                 = defaultMax,
            bool getTotalCount             = false,
            AlbumSortRule?sort             = null,
            NameMatchMode nameMatchMode    = NameMatchMode.Exact,
            AlbumOptionalFields fields     = AlbumOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            maxResults = Math.Min(maxResults, absoluteMax);
            query      = FindHelpers.GetMatchModeAndQueryForSearch(query, ref nameMatchMode);
            var ssl = WebHelper.IsSSL(Request);

            var queryParams = new AlbumCollectionQueryParams(userId, new PagingProperties(start, maxResults, getTotalCount))
            {
                ArtistId       = artistId ?? 0,
                FilterByStatus = purchaseStatuses != null?purchaseStatuses.Value.ToIndividualSelections().ToArray() : null,
                                     NameMatchMode    = nameMatchMode,
                                     Query            = query,
                                     ReleaseEventName = releaseEventName,
                                     Sort             = sort ?? AlbumSortRule.Name,
                                     Tag = tag
            };

            var albums = queries.GetAlbumCollection(queryParams, (afu, shouldShowCollectionStatus) =>
                                                    new AlbumForUserForApiContract(afu, lang, thumbPersister, ssl, fields, shouldShowCollectionStatus));

            return(albums);
        }
コード例 #5
0
 public IEnumerable <AlbumForApiContract> GetTopAlbums(
     int[] ignoreIds,
     ContentLanguagePreference languagePreference = ContentLanguagePreference.Default,
     AlbumOptionalFields fields = AlbumOptionalFields.None)
 {
     return(otherService.GetTopAlbums(languagePreference, fields, ignoreIds ?? new int[0]));
 }
コード例 #6
0
 public IEnumerable <AlbumForApiContract> GetTopAlbums(
     [FromQuery(Name = "ignoreIds[]")] int[] ignoreIds = null,
     ContentLanguagePreference languagePreference      = ContentLanguagePreference.Default,
     AlbumOptionalFields fields = AlbumOptionalFields.None)
 {
     ignoreIds ??= Array.Empty <int>();
     return(_otherService.GetTopAlbums(languagePreference, fields, ignoreIds));
 }
コード例 #7
0
 public AlbumForApiContract[] GetAlbums(int eventId,
                                        AlbumOptionalFields fields     = AlbumOptionalFields.None,
                                        ContentLanguagePreference lang = ContentLanguagePreference.Default)
 {
     return(repository.HandleQuery(ctx => {
         var ev = ctx.Load(eventId);
         return ev.Albums.Select(a => new AlbumForApiContract(a, null, lang, thumbPersister, WebHelper.IsSSL(Request), fields)).ToArray();
     }));
 }
コード例 #8
0
 public AlbumForApiContract(
     Album album,
     ContentLanguagePreference languagePreference,
     IEntryThumbPersister thumbPersister,
     AlbumOptionalFields fields,
     SongOptionalFields songFields = SongOptionalFields.None) :
     this(album, null, languagePreference, thumbPersister, true, fields, songFields)
 {
 }
コード例 #9
0
 public AlbumForApiContract[] GetAlbums(int eventId,
                                        AlbumOptionalFields fields     = AlbumOptionalFields.None,
                                        ContentLanguagePreference lang = ContentLanguagePreference.Default)
 {
     return(repository.HandleQuery(ctx => {
         var ev = ctx.Load(eventId);
         return ev.Albums.Select(a => new AlbumForApiContract(a, null, lang, imageUrlFactory, fields, SongOptionalFields.None)).ToArray();
     }));
 }
コード例 #10
0
 public AlbumForApiContract(
     Album album,
     ContentLanguagePreference languagePreference,
     IAggregatedEntryImageUrlFactory thumbPersister,
     AlbumOptionalFields fields,
     SongOptionalFields songFields = SongOptionalFields.None) :
     this(album, null, languagePreference, thumbPersister, fields, songFields)
 {
 }
コード例 #11
0
        public AlbumForApiContract GetOne(
            int id,
            AlbumOptionalFields fields     = AlbumOptionalFields.None,
            SongOptionalFields songFields  = SongOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            var album = queries.GetAlbumWithMergeRecord(id, (a, m) => new AlbumForApiContract(a, m, lang, thumbPersister, fields, songFields));

            return(album);
        }
コード例 #12
0
ファイル: AlbumApiController.cs プロジェクト: ffdd270/vocadb
        public PartialFindResult <AlbumForApiContract> GetList(
            string query               = "",
            DiscType discTypes         = DiscType.Unknown,
            [FromUri] string[] tagName = null,
            [FromUri] int[] tagId      = null,
            bool childTags             = false,
            [FromUri] int[] artistId   = null,
            ArtistAlbumParticipationStatus artistParticipationStatus = ArtistAlbumParticipationStatus.Everything,
            bool childVoicebanks       = false,
            bool includeMembers        = false,
            string barcode             = null,
            EntryStatus?status         = null,
            DateTime?releaseDateAfter  = null,
            DateTime?releaseDateBefore = null,
            [FromUri] AdvancedSearchFilter[] advancedFilters = null,
            int start                      = 0,
            int maxResults                 = defaultMax,
            bool getTotalCount             = false,
            AlbumSortRule?sort             = null,
            bool preferAccurateMatches     = false,
            bool deleted                   = false,
            NameMatchMode nameMatchMode    = NameMatchMode.Exact,
            AlbumOptionalFields fields     = AlbumOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            var textQuery = SearchTextQuery.Create(query, nameMatchMode);

            var queryParams = new AlbumQueryParams(textQuery, discTypes, start, Math.Min(maxResults, absoluteMax), getTotalCount, sort ?? AlbumSortRule.Name, preferAccurateMatches)
            {
                ArtistParticipation =
                {
                    ArtistIds       = artistId,
                    Participation   = artistParticipationStatus,
                    ChildVoicebanks = childVoicebanks,
                    IncludeMembers  = includeMembers
                },
                Tags               = tagName,
                TagIds             = tagId,
                ChildTags          = childTags,
                Barcode            = barcode,
                Deleted            = deleted,
                ReleaseDateAfter   = releaseDateAfter,
                ReleaseDateBefore  = releaseDateBefore,
                AdvancedFilters    = advancedFilters,
                LanguagePreference = lang
            };

            queryParams.Common.EntryStatus = status;

            var ssl = WebHelper.IsSSL(Request);

            var entries = service.Find(a => new AlbumForApiContract(a, null, lang, thumbPersister, ssl, fields, SongOptionalFields.None), queryParams);

            return(entries);
        }
コード例 #13
0
        public AlbumForApiContract[] GetAlbums(int eventId, 
            AlbumOptionalFields fields = AlbumOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            return repository.HandleQuery(ctx => {

                var ev = ctx.Load(eventId);
                return ev.Albums.Select(a => new AlbumForApiContract(a, null, lang, thumbPersister, WebHelper.IsSSL(Request), fields)).ToArray();

            });
        }
コード例 #14
0
        public AlbumForUserForApiContract(
            AlbumForUser albumForUser,
            ContentLanguagePreference languagePreference,
            IEntryThumbPersister thumbPersister,
            bool ssl,
            AlbumOptionalFields fields,
            bool shouldShowCollectionStatus)
        {
            Album  = new AlbumForApiContract(albumForUser.Album, null, languagePreference, thumbPersister, ssl, fields, SongOptionalFields.None);
            Rating = albumForUser.Rating;

            if (shouldShowCollectionStatus)
            {
                MediaType      = albumForUser.MediaType;
                PurchaseStatus = albumForUser.PurchaseStatus;
            }
        }
コード例 #15
0
		public AlbumForUserForApiContract(
			AlbumForUser albumForUser, 
			ContentLanguagePreference languagePreference, 
			IEntryThumbPersister thumbPersister,
			bool ssl,
			AlbumOptionalFields fields,
			bool shouldShowCollectionStatus) {

			Album = new AlbumForApiContract(albumForUser.Album, null, languagePreference, thumbPersister, ssl, fields);
			Rating = albumForUser.Rating;

			if (shouldShowCollectionStatus) {
				MediaType = albumForUser.MediaType;
				PurchaseStatus = albumForUser.PurchaseStatus;
			}

		}
コード例 #16
0
        public PartialFindResult <AlbumForUserForApiContract> GetAlbumCollection(
            int id,
            string query = "",
            int?tagId    = null,
            string tag   = null,
            int?artistId = null,
            [FromUri] PurchaseStatuses?purchaseStatuses = null,
            int releaseEventId  = 0,
            DiscType albumTypes = DiscType.Unknown,
            [FromUri] AdvancedSearchFilter[] advancedFilters = null,
            int start                      = 0,
            int maxResults                 = defaultMax,
            bool getTotalCount             = false,
            AlbumSortRule?sort             = null,
            NameMatchMode nameMatchMode    = NameMatchMode.Exact,
            AlbumOptionalFields fields     = AlbumOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            maxResults = Math.Min(maxResults, absoluteMax);
            var textQuery = SearchTextQuery.Create(query, nameMatchMode);
            var ssl       = WebHelper.IsSSL(Request);

            var queryParams = new AlbumCollectionQueryParams(id, new PagingProperties(start, maxResults, getTotalCount))
            {
                AlbumType      = albumTypes,
                ArtistId       = artistId ?? 0,
                FilterByStatus = purchaseStatuses != null?purchaseStatuses.Value.ToIndividualSelections().ToArray() : null,
                                     TextQuery       = textQuery,
                                     ReleaseEventId  = releaseEventId,
                                     Sort            = sort ?? AlbumSortRule.Name,
                                     TagId           = tagId ?? 0,
                                     Tag             = tag,
                                     AdvancedFilters = advancedFilters
            };

            var albums = queries.GetAlbumCollection(queryParams, (afu, shouldShowCollectionStatus) =>
                                                    new AlbumForUserForApiContract(afu, lang, thumbPersister, ssl, fields, shouldShowCollectionStatus));

            return(albums);
        }
コード例 #17
0
        public AlbumForUserForApiContract(
            AlbumForUser albumForUser,
            ContentLanguagePreference languagePreference,
            IAggregatedEntryImageUrlFactory thumbPersister,
            AlbumOptionalFields fields,
            bool shouldShowCollectionStatus,
            bool includeUser = false)
        {
            Album  = albumForUser != null ? new AlbumForApiContract(albumForUser.Album, null, languagePreference, thumbPersister, fields, SongOptionalFields.None) : null;
            Rating = albumForUser?.Rating ?? 0;

            if (shouldShowCollectionStatus)
            {
                MediaType      = albumForUser?.MediaType ?? null;
                PurchaseStatus = albumForUser?.PurchaseStatus ?? null;
            }

            if (includeUser)
            {
                User = albumForUser != null ? new UserForApiContract(albumForUser.User) : null;
            }
        }
コード例 #18
0
        public PartialFindResult <AlbumForApiContract> GetList(
            string query       = "",
            DiscType discTypes = DiscType.Unknown,
            string tag         = null,
            int?artistId       = null,
            ArtistAlbumParticipationStatus artistParticipationStatus = ArtistAlbumParticipationStatus.Everything,
            bool childVoicebanks           = false,
            string barcode                 = null,
            EntryStatus?status             = null,
            int start                      = 0,
            int maxResults                 = defaultMax,
            bool getTotalCount             = false,
            AlbumSortRule?sort             = null,
            bool preferAccurateMatches     = false,
            bool deleted                   = false,
            NameMatchMode nameMatchMode    = NameMatchMode.Exact,
            AlbumOptionalFields fields     = AlbumOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            var textQuery = SearchTextQuery.Create(query, nameMatchMode);

            var queryParams = new AlbumQueryParams(textQuery, discTypes, start, Math.Min(maxResults, absoluteMax), false, getTotalCount, sort ?? AlbumSortRule.Name, preferAccurateMatches)
            {
                Tag      = tag,
                ArtistId = artistId ?? 0,
                ArtistParticipationStatus = artistParticipationStatus,
                ChildVoicebanks           = childVoicebanks,
                Barcode = barcode,
                Deleted = deleted
            };

            queryParams.Common.EntryStatus = status;

            var ssl = WebHelper.IsSSL(Request);

            var entries = service.Find(a => new AlbumForApiContract(a, null, lang, thumbPersister, ssl, fields), queryParams);

            return(entries);
        }
コード例 #19
0
        public AlbumForApiContract GetOne(int id, AlbumOptionalFields fields = AlbumOptionalFields.None, ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            var ssl = WebHelper.IsSSL(Request);
            var album = service.GetAlbumWithMergeRecord(id, (a, m) => new AlbumForApiContract(a, m, lang, thumbPersister, ssl, fields));

            return album;
        }
コード例 #20
0
        public PartialFindResult<AlbumForApiContract> GetList(
            string query = "",
            DiscType discTypes = DiscType.Unknown,
            string tag = null,
            int? artistId = null,
            ArtistAlbumParticipationStatus artistParticipationStatus = ArtistAlbumParticipationStatus.Everything,
            bool childVoicebanks = false,
            string barcode = null,
            EntryStatus? status = null,
            int start = 0,
            int maxResults = defaultMax,
            bool getTotalCount = false,
            AlbumSortRule? sort = null,
            NameMatchMode nameMatchMode = NameMatchMode.Exact,
            AlbumOptionalFields fields = AlbumOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            query = FindHelpers.GetMatchModeAndQueryForSearch(query, ref nameMatchMode);

            var queryParams = new AlbumQueryParams(query, discTypes, start, Math.Min(maxResults, absoluteMax), false, getTotalCount, nameMatchMode, sort ?? AlbumSortRule.Name) {
                Tag = tag,
                ArtistId = artistId ?? 0,
                ArtistParticipationStatus = artistParticipationStatus,
                ChildVoicebanks = childVoicebanks,
                Barcode = barcode
            };
            queryParams.Common.EntryStatus = status;

            var ssl = WebHelper.IsSSL(Request);

            var entries = service.Find(a => new AlbumForApiContract(a, null, lang, thumbPersister, ssl, fields), queryParams);

            return entries;
        }
コード例 #21
0
 public AlbumForApiContract[] GetAlbums(int eventId,
                                        AlbumOptionalFields fields     = AlbumOptionalFields.None,
                                        ContentLanguagePreference lang = ContentLanguagePreference.Default) => _queries.GetAlbums(eventId, fields, lang);
コード例 #22
0
        private AlbumForApiContract[] GetTopAlbums(ISession session, int[] recentIds, ContentLanguagePreference languagePreference, AlbumOptionalFields fields)
        {
            var minRatings = 2;             // Minimum number of ratings
            var sampleSize = 300;           // Get this many popular albums to be rotated when cache expires
            var albumCount = 7;             // This many albums are shown, the albums are rotated when cache expires
            var cacheKey   = "OtherService.PopularAlbums." + languagePreference;
            var item       = (TranslatedAlbumContract[])cache.Get(cacheKey);

            if (item != null)
            {
                return(item.Select(a => new AlbumForApiContract(a, LanguagePreference, thumbPersister, fields)).ToArray());
            }

            // If only a small number of rated albums, reduce minimum ratings count
            var totalRatedAlbumCount = session.Query <Album>().Count(a => !a.Deleted && a.RatingCount >= minRatings && a.RatingAverageInt >= 300);

            if (totalRatedAlbumCount < albumCount)
            {
                minRatings = 1;
            }

            // Find Ids of albums that match the popularity filters, take maximum of sampleSize albums
            var popularIds = session.Query <Album>()
                             .WhereHasArtist(AppConfig.FilteredArtistId)
                             .Where(a => !a.Deleted &&
                                    a.RatingCount >= minRatings && a.RatingAverageInt >= 300 &&         // Filter by number of ratings and average rating
                                    !recentIds.Contains(a.Id))                                          // Filter out recent albums (that are already shown)
                             .OrderByDescending(a => a.RatingTotal)
                             .Select(a => a.Id)
                             .Take(sampleSize)
                             .ToArray();

            // Pick random albums to be displayed from the group of popular albums
            var randomIds = CollectionHelper
                            .GetRandomItems(popularIds, albumCount)
                            .ToArray();

            var random = session.Query <Album>()
                         .Where(a => randomIds.Contains(a.Id))
                         .OrderByDescending(a => a.RatingAverageInt)
                         .ToArray();

            var popularAlbumsCached = random
                                      .Select(a => new TranslatedAlbumContract(a))
                                      .ToArray();

            var popularAlbumContracts = random
                                        .Select(a => new AlbumForApiContract(a, null, languagePreference, thumbPersister, true, fields, SongOptionalFields.None))
                                        .ToArray();

            cache.Add(cacheKey, popularAlbumsCached, DateTime.Now + TimeSpan.FromHours(24));

            return(popularAlbumContracts);
        }
コード例 #23
0
 public AlbumForApiContract[] GetTopAlbums(ContentLanguagePreference languagePreference, AlbumOptionalFields fields, int[] ignoreIds)
 {
     return(HandleQuery(session => GetTopAlbums(session, ignoreIds, languagePreference, fields)));
 }
コード例 #24
0
        private AlbumForApiContract[] GetRecentAlbums(ISession session, ContentLanguagePreference languagePreference, AlbumOptionalFields fields)
        {
            var cacheKey = "OtherService.RecentAlbums." + languagePreference;
            var item     = (TranslatedAlbumContract[])cache.Get(cacheKey);

            if (item != null)
            {
                return(item.Select(a => new AlbumForApiContract(a, LanguagePreference, thumbPersister, fields)).ToArray());
            }

            var now = DateTime.Now;

            var upcoming = session.Query <Album>()
                           .WhereHasArtist(AppConfig.FilteredArtistId)
                           .Where(a => !a.Deleted)
                           .WhereHasReleaseDate()
                           .WhereReleaseDateIsAfter(now)
                           .OrderByReleaseDate(SortDirection.Ascending)
                           .Take(4)
                           .ToArray();

            var recent = session.Query <Album>()
                         .WhereHasArtist(AppConfig.FilteredArtistId)
                         .Where(a => !a.Deleted)
                         .WhereHasReleaseDate()
                         .WhereReleaseDateIsBefore(now)
                         .OrderByReleaseDate(SortDirection.Descending)
                         .Take(3)
                         .ToArray();

            var newAlbums = upcoming.Reverse().Concat(recent)
                            .Select(a => new TranslatedAlbumContract(a))
                            .ToArray();

            var newAlbumContracts = upcoming.Reverse().Concat(recent)
                                    .Select(a => new AlbumForApiContract(a, null, languagePreference, thumbPersister, true, fields, SongOptionalFields.None))
                                    .ToArray();

            cache.Add(cacheKey, newAlbums, DateTime.Now + TimeSpan.FromHours(1));

            return(newAlbumContracts);
        }
コード例 #25
0
 public IEnumerable <AlbumForApiContract> GetNewAlbums(
     ContentLanguagePreference languagePreference = ContentLanguagePreference.Default,
     AlbumOptionalFields fields = AlbumOptionalFields.None)
 {
     return(otherService.GetRecentAlbums(languagePreference, fields));
 }
コード例 #26
0
        public AlbumForApiContract(TranslatedAlbumContract album, ContentLanguagePreference languagePreference, IEntryThumbPersister thumbPersister, AlbumOptionalFields fields)
        {
            ParamIs.NotNull(() => album);

            ArtistString  = album.TranslatedArtistString.GetBestMatch(languagePreference);
            CreateDate    = album.CreateDate;
            Deleted       = album.Deleted;
            DiscType      = album.DiscType;
            Id            = album.Id;
            Name          = album.Names.SortNames[languagePreference];
            RatingAverage = album.RatingAverage;
            RatingCount   = album.RatingCount;
            ReleaseDate   = album.ReleaseDate;
            Status        = album.Status;
            Version       = album.Version;

            if (fields.HasFlag(AlbumOptionalFields.AdditionalNames))
            {
                AdditionalNames = album.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            }

            if (fields.HasFlag(AlbumOptionalFields.MainPicture))
            {
                MainPicture = new EntryThumbForApiContract(new EntryThumb(album, album.CoverPictureMime), thumbPersister);
            }

            if (fields.HasFlag(AlbumOptionalFields.ReleaseEvent))
            {
                ReleaseEvent = album.ReleaseEvent;
            }
        }
コード例 #27
0
 public AlbumForApiContract[] GetRecentAlbums(ContentLanguagePreference languagePreference, AlbumOptionalFields fields)
 {
     return(HandleQuery(session => GetRecentAlbums(session, languagePreference, fields)));
 }
コード例 #28
0
        public PartialFindResult<AlbumForUserForApiContract> GetAlbumCollection(
            int userId,
            string query = "",
            string tag = null,
            int? artistId = null,
            [FromUri] PurchaseStatuses? purchaseStatuses = null,
            string releaseEventName = null,
            int start = 0,
            int maxResults = defaultMax,
            bool getTotalCount = false,
            AlbumSortRule? sort = null,
            NameMatchMode nameMatchMode = NameMatchMode.Exact,
            AlbumOptionalFields fields = AlbumOptionalFields.None,
            ContentLanguagePreference lang = ContentLanguagePreference.Default)
        {
            maxResults = Math.Min(maxResults, absoluteMax);
            query = FindHelpers.GetMatchModeAndQueryForSearch(query, ref nameMatchMode);
            var ssl = WebHelper.IsSSL(Request);

            var queryParams = new AlbumCollectionQueryParams(userId, new PagingProperties(start, maxResults, getTotalCount)) {
                ArtistId = artistId ?? 0,
                FilterByStatus = purchaseStatuses != null ? purchaseStatuses.Value.ToIndividualSelections().ToArray() : null,
                NameMatchMode = nameMatchMode,
                Query = query,
                ReleaseEventName = releaseEventName,
                Sort = sort ?? AlbumSortRule.Name,
                Tag = tag
            };

            var albums = queries.GetAlbumCollection(queryParams, (afu, shouldShowCollectionStatus) =>
                new AlbumForUserForApiContract(afu, lang, thumbPersister, ssl, fields, shouldShowCollectionStatus));

            return albums;
        }
コード例 #29
0
        private AlbumForApiContract[] GetTopAlbumsCached(ISession session, int[] recentIds, ContentLanguagePreference languagePreference, AlbumOptionalFields fields)
        {
            var cacheKey = $"OtherService.PopularAlbums.{languagePreference}";

            return(_cache.GetOrInsert(cacheKey, CachePolicy.AbsoluteExpiration(TimeSpan.FromHours(24)), () => GetTopAlbums(session, recentIds, languagePreference, fields)));
        }
コード例 #30
0
        public AlbumForApiContract(
            Album album, AlbumMergeRecord mergeRecord,
            ContentLanguagePreference languagePreference,
            IAggregatedEntryImageUrlFactory thumbPersister,
            AlbumOptionalFields fields,
            SongOptionalFields songFields)
        {
            ArtistString        = album.ArtistString[languagePreference];
            CatalogNumber       = album.OriginalRelease != null ? album.OriginalRelease.CatNum : null;
            CreateDate          = album.CreateDate;
            DefaultName         = album.DefaultName;
            DefaultNameLanguage = album.Names.SortNames.DefaultLanguage;
            DiscType            = album.DiscType;
            Id            = album.Id;
            Name          = album.Names.SortNames[languagePreference];
            RatingAverage = album.RatingAverage;
            RatingCount   = album.RatingCount;
            ReleaseDate   = new OptionalDateTimeContract(album.OriginalReleaseDate);
            Status        = album.Status;
            Version       = album.Version;

            if (fields.HasFlag(AlbumOptionalFields.AdditionalNames))
            {
                AdditionalNames = album.Names.GetAdditionalNamesStringForLanguage(languagePreference);
            }

            if (fields.HasFlag(AlbumOptionalFields.Artists))
            {
                Artists = album.Artists.Select(a => new ArtistForAlbumForApiContract(a, languagePreference)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.Description))
            {
                Description = album.Description[languagePreference];
            }

            if (fields.HasFlag(AlbumOptionalFields.Discs))
            {
                Discs = album.Discs.Select(d => new AlbumDiscPropertiesContract(d)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.Identifiers))
            {
                Identifiers = album.Identifiers.Select(i => new AlbumIdentifierContract(i)).ToArray();
            }

            if (thumbPersister != null && fields.HasFlag(AlbumOptionalFields.MainPicture) && album.Thumb != null)
            {
                MainPicture = new EntryThumbForApiContract(album.Thumb, thumbPersister);
            }

            if (fields.HasFlag(AlbumOptionalFields.Names))
            {
                Names = album.Names.Select(n => new LocalizedStringContract(n)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.PVs))
            {
                PVs = album.PVs.Select(p => new PVContract(p)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.ReleaseEvent))
            {
                ReleaseEvent = album.OriginalReleaseEvent != null ? new ReleaseEventForApiContract(album.OriginalReleaseEvent, languagePreference, ReleaseEventOptionalFields.None, thumbPersister) : null;
            }

            if (fields.HasFlag(AlbumOptionalFields.Tags))
            {
                Tags = album.Tags.ActiveUsages.Select(u => new TagUsageForApiContract(u, languagePreference)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.Tracks))
            {
                Tracks = album.Songs.Select(s => new SongInAlbumForApiContract(s, languagePreference, songFields)).ToArray();
            }

            if (fields.HasFlag(AlbumOptionalFields.WebLinks))
            {
                WebLinks = album.WebLinks.Select(w => new WebLinkForApiContract(w)).ToArray();
            }

            if (mergeRecord != null)
            {
                MergedTo = mergeRecord.Target.Id;
            }
        }
コード例 #31
0
        private AlbumForApiContract[] GetRecentAlbums(ISession session, ContentLanguagePreference languagePreference, AlbumOptionalFields fields)
        {
            var cacheKey = $"OtherService.RecentAlbums.{languagePreference}";

            return(_cache.GetOrInsert(cacheKey, CachePolicy.AbsoluteExpiration(TimeSpan.FromHours(1)), () =>
            {
                var now = DateTime.Now;

                var upcoming = session.Query <Album>()
                               .WhereHasArtist(AppConfig.FilteredArtistId)
                               .Where(a => !a.Deleted)
                               .WhereHasReleaseDate()
                               .WhereReleaseDateIsAfter(now)
                               .OrderByReleaseDate(SortDirection.Ascending)
                               .Take(4)
                               .ToArray();

                var recent = session.Query <Album>()
                             .WhereHasArtist(AppConfig.FilteredArtistId)
                             .Where(a => !a.Deleted)
                             .WhereHasReleaseDate()
                             .WhereReleaseDateIsBefore(now)
                             .OrderByReleaseDate(SortDirection.Descending)
                             .Take(3)
                             .ToArray();

                var newAlbumContracts = upcoming.Reverse().Concat(recent)
                                        .Select(a => new AlbumForApiContract(a, null, languagePreference, _thumbPersister, fields, SongOptionalFields.None))
                                        .ToArray();

                return newAlbumContracts;
            }));
        }