public ActionResult ByPV(PVService service, string pvId, ContentLanguagePreference? lang, string callback,
DataFormat format = DataFormat.Auto)
{
var song = Service.GetSongWithPV(s => new SongForApiContract(s, lang ?? ContentLanguagePreference.Default), service, pvId);
return Object(song, format, callback);
}
public SongWithComponentsContract(Song song, ContentLanguagePreference languagePreference, bool includeArtists = false)
: base(song, languagePreference) {
if (includeArtists)
Artists = song.ArtistList.Select(a => new ArtistContract(a, languagePreference)).ToArray();
}
public UnifiedCommentContract(Comment comment, ContentLanguagePreference languagePreference)
: base(comment)
{
Entry = new EntryRefWithNameContract(comment.Entry, languagePreference);
ArtistString = GetArtistString(comment.Entry, languagePreference);
SongThumbUrl = GetSongThumbUrl(comment.Entry);
}
public static EntryNameContract GetName(INameManager nameManager, ContentLanguagePreference languagePreference) {
var primary = nameManager.SortNames[languagePreference];
return new EntryNameContract(primary, GetAdditionalNames(nameManager.AllValues, primary));
}
public static IQueryable<Album> AddOrder(IQueryable<Album> criteria, AlbumSortRule sortRule, ContentLanguagePreference languagePreference) {
switch (sortRule) {
case AlbumSortRule.Name:
return FindHelpers.AddNameOrder(criteria, languagePreference);
case AlbumSortRule.ReleaseDate:
return AddReleaseRestriction(criteria)
.OrderByDescending(a => a.OriginalRelease.ReleaseDate.Year)
.ThenByDescending(a => a.OriginalRelease.ReleaseDate.Month)
.ThenByDescending(a => a.OriginalRelease.ReleaseDate.Day);
case AlbumSortRule.AdditionDate:
return criteria.OrderByDescending(a => a.CreateDate);
case AlbumSortRule.RatingAverage:
return criteria.OrderByDescending(a => a.RatingAverageInt)
.ThenByDescending(a => a.RatingCount);
case AlbumSortRule.NameThenReleaseDate:
return FindHelpers.AddNameOrder(criteria, languagePreference)
.ThenBy(a => a.OriginalRelease.ReleaseDate.Year)
.ThenBy(a => a.OriginalRelease.ReleaseDate.Month)
.ThenBy(a => a.OriginalRelease.ReleaseDate.Day);
}
return criteria;
}
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);
}
}
public SongWithPVAndVoteContract(Song song, SongVoteRating vote, ContentLanguagePreference languagePreference)
: base(song, languagePreference) {
PVs = song.PVs.Select(p => new PVContract(p)).ToArray();
Vote = vote;
}
public AlbumWithArchivedVersionsContract(Album album, ContentLanguagePreference languagePreference)
: base(album, languagePreference)
{
ParamIs.NotNull(() => album);
ArchivedVersions = album.ArchivedVersionsManager.Versions.Select(a => new ArchivedAlbumVersionContract(a)).ToArray();
}
public SongInAlbumEditContract(SongInAlbum songInAlbum, ContentLanguagePreference languagePreference) {
ParamIs.NotNull(() => songInAlbum);
DiscNumber = songInAlbum.DiscNumber;
SongInAlbumId = songInAlbum.Id;
TrackNumber = songInAlbum.TrackNumber;
ArtistString = string.Empty;
SongAdditionalNames = string.Empty;
SongId = 0;
var song = songInAlbum.Song;
if (song != null) {
Artists = song.ArtistList.Select(a => new ArtistContract(a, languagePreference)).ToArray();
ArtistString = song.ArtistString[languagePreference];
SongName = song.TranslatedName[languagePreference];
SongAdditionalNames = string.Join(", ", song.AllNames.Where(n => n != SongName));
SongId = song.Id;
} else {
Artists = new ArtistContract[0];
SongName = songInAlbum.Name;
}
IsCustomTrack = song == null;
}
public static IQueryable<AlbumForUser> OrderBy(this IQueryable<AlbumForUser> query, AlbumSortRule sortRule, ContentLanguagePreference languagePreference) {
switch (sortRule) {
case AlbumSortRule.Name:
return AddNameOrder(query, languagePreference);
case AlbumSortRule.CollectionCount:
return query.OrderByDescending(a => a.Album.UserCollections.Count);
case AlbumSortRule.ReleaseDate:
return query
.WhereHasReleaseDate()
.OrderByReleaseDate();
case AlbumSortRule.ReleaseDateWithNulls:
return query.OrderByReleaseDate();
case AlbumSortRule.AdditionDate:
return query.OrderByDescending(a => a.Album.CreateDate);
case AlbumSortRule.RatingAverage:
return query.OrderByDescending(a => a.Album.RatingAverageInt)
.ThenByDescending(a => a.Album.RatingCount);
case AlbumSortRule.RatingTotal:
return query.OrderByDescending(a => a.Album.RatingTotal)
.ThenByDescending(a => a.Album.RatingAverageInt);
case AlbumSortRule.NameThenReleaseDate:
return AddNameOrder(query, languagePreference)
.ThenBy(a => a.Album.OriginalRelease.ReleaseDate.Year)
.ThenBy(a => a.Album.OriginalRelease.ReleaseDate.Month)
.ThenBy(a => a.Album.OriginalRelease.ReleaseDate.Day);
}
return query;
}
public AlbumForArtistEditContract(ArtistForAlbum artistForAlbum, ContentLanguagePreference languagePreference)
{
AlbumId = artistForAlbum.Album.Id;
AlbumName = artistForAlbum.Album.TranslatedName[languagePreference];
AlbumAdditionalNames = string.Join(", ", artistForAlbum.Album.AllNames.Where(n => n != AlbumName));
ArtistForAlbumId = artistForAlbum.Id;
}
public ReleaseEventSeriesWithEventsContract(ReleaseEventSeries series, IEnumerable<ReleaseEvent> events, ContentLanguagePreference languagePreference)
: base(series)
{
ParamIs.NotNull(() => events);
Events = events.OrderBy(e => e.SeriesNumber).Select(e => new ReleaseEventContract(e)).ToArray();
}
public EntryRefWithCommonPropertiesContract(Song entry, ContentLanguagePreference languagePreference)
: base(entry, languagePreference) {
ArtistString = entry.ArtistString[languagePreference];
EntryTypeName = SongTypeNames.ResourceManager.GetString(entry.SongType.ToString());
}
public SongDetailsContract(Song song, ContentLanguagePreference languagePreference) {
Song = new SongContract(song, languagePreference);
AdditionalNames = string.Join(", ", song.AllNames.Where(n => n != Song.Name).Distinct());
Albums = song.Albums.Select(a => new AlbumContract(a.Album, languagePreference)).Distinct().OrderBy(a => a.Name).ToArray();
AlternateVersions = song.AlternateVersions.Select(s => new SongContract(s, languagePreference)).ToArray();
Artists = song.Artists.Select(a => new ArtistForSongContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
ArtistString = song.ArtistString[languagePreference];
CreateDate = song.CreateDate;
Deleted = song.Deleted;
LikeCount = song.UserFavorites.Count(f => f.Rating == SongVoteRating.Like);
LyricsFromParents = song.LyricsFromParents.Select(l => new LyricsForSongContract(l)).ToArray();
Notes = song.Notes;
OriginalVersion = (song.OriginalVersion != null && !song.OriginalVersion.Deleted ? new SongContract(song.OriginalVersion, languagePreference) : null);
// TODO (PERF): this might be handled through a special query if the list is long
Pools =
song.ListLinks
.Where(l => l.List.FeaturedCategory == SongListFeaturedCategory.Pools)
.OrderBy(l => l.List.Name).Take(3)
.Select(l => new SongListBaseContract(l.List))
.ToArray();
ListCount = song.ListLinks.Count;
PVs = song.PVs.Select(p => new PVContract(p)).ToArray();
Tags = song.Tags.Usages.Select(u => new TagUsageContract(u)).OrderByDescending(t => t.Count).ToArray();
TranslatedName = new TranslatedStringContract(song.TranslatedName);
WebLinks = song.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
}
public EntryForApiContract(Album album, ContentLanguagePreference languagePreference, IEntryThumbPersister thumbPersister, bool ssl,
EntryOptionalFields includedFields)
: this(album, languagePreference) {
ArtistString = album.ArtistString[languagePreference];
CreateDate = album.CreateDate;
DiscType = album.DiscType;
Status = album.Status;
if (includedFields.HasFlag(EntryOptionalFields.MainPicture) && album.CoverPictureData != null) {
MainPicture = new EntryThumbForApiContract(new EntryThumb(album, album.CoverPictureMime), thumbPersister, ssl);
}
if (includedFields.HasFlag(EntryOptionalFields.Names)) {
Names = album.Names.Select(n => new LocalizedStringContract(n)).ToArray();
}
if (includedFields.HasFlag(EntryOptionalFields.Tags)) {
Tags = album.Tags.Usages.Select(u => new TagUsageForApiContract(u)).ToArray();
}
if (includedFields.HasFlag(EntryOptionalFields.WebLinks)) {
WebLinks = album.WebLinks.Select(w => new ArchivedWebLinkContract(w)).ToArray();
}
}
public SongInListForApiContract(SongInList songInList, ContentLanguagePreference languagePreference, SongOptionalFields fields) {
this.Notes = songInList.Notes;
this.Order = songInList.Order;
this.Song = new SongForApiContract(songInList.Song, null, languagePreference, fields);
}
public ArtistWithArchivedVersionsContract(Artist artist, ContentLanguagePreference languagePreference)
: base(artist, languagePreference)
{
ParamIs.NotNull(() => artist);
ArchivedVersions = artist.ArchivedVersionsManager.Versions.Select(a => new ArchivedArtistVersionContract(a)).ToArray();
}
public SongWithArchivedVersionsContract(Song song, ContentLanguagePreference languagePreference)
: base(song, languagePreference)
{
ParamIs.NotNull(() => song);
ArchivedVersions = song.ArchivedVersionsManager.Versions.Select(a => new ArchivedSongVersionContract(a)).OrderByDescending(v => v.Version).ToArray();
//Author = (ArchivedVersions.Any() && ArchivedVersions.Last().Author != null ? ArchivedVersions.Last().Author : null);
}
public SongWithAlbumAndPVsContract(Song song, ContentLanguagePreference languagePreference, bool getPVs)
: base(song, languagePreference)
{
if (getPVs)
PVs = song.PVs.Select(p => new PVContract(p)).ToArray();
else
PVs = new PVContract[] {};
}
public SongInListContract(SongInList songInList, ContentLanguagePreference languagePreference)
{
ParamIs.NotNull(() => songInList);
Order = songInList.Order;
Notes = songInList.Notes;
Song = new SongWithAdditionalNamesContract(songInList.Song, languagePreference);
}
public ArtistForUserContract(OwnedArtistForUser ownedArtistForUser, ContentLanguagePreference languagePreference)
{
ParamIs.NotNull(() => ownedArtistForUser);
Artist = new ArtistContract(ownedArtistForUser.Artist, languagePreference);
Id = ownedArtistForUser.Id;
User = new UserContract(ownedArtistForUser.User);
}
public static EntryForPictureDisplayContract Create(IEntryWithNames entry, string mime, byte[] bytes, ContentLanguagePreference languagePreference) {
var name = entry.Names.SortNames[languagePreference];
var pic = (bytes != null ? new PictureContract(bytes, mime) : null);
return new EntryForPictureDisplayContract(entry.EntryType, entry.Id, name, entry.Version, pic);
}
private bool TryGetLanguagePreferenceFromRequest(ref ContentLanguagePreference languagePreference) {
if (HttpContext.Current == null || string.IsNullOrEmpty(HttpContext.Current.Request.Params[LangParamName]))
return false;
return Enum.TryParse(HttpContext.Current.Request.Params[LangParamName], out languagePreference);
}
public GroupForArtistContract(GroupForArtist groupForArtist, ContentLanguagePreference languagePreference)
{
ParamIs.NotNull(() => groupForArtist);
Group = new ArtistWithAdditionalNamesContract(groupForArtist.Group, languagePreference);
Id = groupForArtist.Id;
Member = new ArtistWithAdditionalNamesContract(groupForArtist.Member, languagePreference);
}
private string GetVocalistStr(SongInAlbum track, ContentLanguagePreference languagePreference) {
if (track.Song == null)
return string.Empty;
return string.Join(", ", ArtistHelper.GetVocalistNames(track.Song.Artists, languagePreference));
}
private string GetProducerStr(SongInAlbum track, ContentLanguagePreference languagePreference) {
if (track.Song == null)
return string.Empty;
return string.Join(", ", ArtistHelper.GetProducerNames(track.Song.Artists, SongHelper.IsAnimation(track.Song.SongType), languagePreference));
}
public SongInAlbumContract(SongInAlbum songInAlbum, ContentLanguagePreference languagePreference)
{
ParamIs.NotNull(() => songInAlbum);
DiscNumber = songInAlbum.DiscNumber;
Id = songInAlbum.Id;
Song = new SongWithAdditionalNamesContract(songInAlbum.Song, languagePreference);
TrackNumber = songInAlbum.TrackNumber;
}
public ReleaseEventDetailsContract(ReleaseEvent releaseEvent, ContentLanguagePreference languagePreference)
: base(releaseEvent)
{
ParamIs.NotNull(() => releaseEvent);
Albums = releaseEvent.Albums.Select(a => new AlbumWithAdditionalNamesContract(a, languagePreference)).OrderBy(a => a.Name).ToArray();
Series = (releaseEvent.Series != null ? new ReleaseEventSeriesContract(releaseEvent.Series) : null);
SeriesNumber = releaseEvent.SeriesNumber;
}
public FavoriteSongForUserContract(FavoriteSongForUser favoriteSongForUser, ContentLanguagePreference languagePreference)
{
ParamIs.NotNull(() => favoriteSongForUser);
Id = favoriteSongForUser.Id;
Rating = favoriteSongForUser.Rating;
Song = new SongContract(favoriteSongForUser.Song, languagePreference);
User = new UserBaseContract(favoriteSongForUser.User);
}
private string GetArtistString(IEntryBase entry, ContentLanguagePreference languagePreference)
{
if (entry is Album)
return ((Album)entry).ArtistString[languagePreference];
else if (entry is Song)
return ((Song)entry).ArtistString[languagePreference];
else
return null;
}
public RelatedSongsContract GetRelated(int id, SongOptionalFields fields = SongOptionalFields.None, ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
return(queries.GetRelatedSongs(id, fields, lang));
}
public static EntryNameContract GetName(INameManager nameManager, ContentLanguagePreference languagePreference)
{
var primary = nameManager.SortNames[languagePreference];
return(new EntryNameContract(primary, GetAdditionalNames(nameManager.AllValues, primary)));
}
public static IOrderedQueryable <AlbumForUser> OrderByAlbumName(this IQueryable <AlbumForUser> criteria, ContentLanguagePreference languagePreference)
{
switch (languagePreference)
{
case ContentLanguagePreference.Japanese:
return(criteria.OrderBy(e => e.Album.Names.SortNames.Japanese));
case ContentLanguagePreference.English:
return(criteria.OrderBy(e => e.Album.Names.SortNames.English));
default:
return(criteria.OrderBy(e => e.Album.Names.SortNames.Romaji));
}
}
public ReleaseEventSeriesForEditContract(ReleaseEventSeries series, ContentLanguagePreference languagePreference) : base(series, languagePreference)
{
DefaultNameLanguage = series.TranslatedName.DefaultLanguage;
Names = series.Names.Select(n => new LocalizedStringWithIdContract(n)).ToArray();
WebLinks = series.WebLinks.Select(w => new WebLinkContract(w)).OrderBy(w => w.DescriptionOrUrl).ToArray();
}
public static IQueryable <Artist> OrderByArtistRule(this IQueryable <Artist> criteria, ArtistSortRule sortRule, ContentLanguagePreference languagePreference)
{
switch (sortRule)
{
case ArtistSortRule.Name:
return(FindHelpers.AddNameOrder(criteria, languagePreference));
case ArtistSortRule.AdditionDate:
return(criteria.OrderByDescending(a => a.CreateDate));
}
return(criteria);
}
public static IQueryable <Song> AddOrder(this IQueryable <Song> criteria, SongSortRule sortRule, ContentLanguagePreference languagePreference)
{
switch (sortRule)
{
case SongSortRule.Name:
return(criteria.AddNameOrder(languagePreference));
case SongSortRule.AdditionDate:
return(criteria.OrderByDescending(a => a.CreateDate));
case SongSortRule.FavoritedTimes:
return(criteria.OrderByDescending(a => a.FavoritedTimes));
case SongSortRule.RatingScore:
return(criteria.OrderByDescending(a => a.RatingScore));
}
return(criteria);
}
public static IOrderedQueryable <T> OrderByName <T>(this IQueryable <T> criteria, ContentLanguagePreference languagePreference) where T : IArtistLink
{
switch (languagePreference)
{
case ContentLanguagePreference.Japanese:
return(criteria.OrderBy(e => e.Artist.Names.SortNames.Japanese));
case ContentLanguagePreference.English:
return(criteria.OrderBy(e => e.Artist.Names.SortNames.English));
default:
return(criteria.OrderBy(e => e.Artist.Names.SortNames.Romaji));
}
}
public TagWithArchivedVersionsContract(Tag tag, ContentLanguagePreference languagePreference)
: base(tag, languagePreference)
{
ArchivedVersions = tag.ArchivedVersionsManager.Versions.Select(
a => new ArchivedTagVersionContract(a)).ToArray();
}
public EntryNameContract GetEntryName(ContentLanguagePreference languagePreference)
{
return(new EntryNameContract(name));
}
public ArtistForApiContract GetOne(int id,
ArtistOptionalFields fields = ArtistOptionalFields.None,
ArtistRelationsFields relations = ArtistRelationsFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default) => _queries.GetWithMergeRecord(id, (a, m, ctx) => GetArtist(a, m, fields, relations, lang, ctx));
private string GetFieldValue(string fieldName, SongInAlbum track, ContentLanguagePreference languagePreference)
{
var album = track.Album;
switch (fieldName.ToLowerInvariant())
{
// Album title
case "album":
return(album.Names.SortNames[languagePreference]);
// Artists for album
case "albumartist":
return(album.ArtistString[languagePreference]);
case "album artist": // foobar style
return(album.ArtistString[languagePreference]);
case "albummaincircle":
var circle = ArtistHelper.GetMainCircle(album.Artists.ToArray(), AlbumHelper.IsAnimation(album.DiscType));
return(circle != null ? circle.TranslatedName[languagePreference] : GetAlbumMainProducersStr(album, languagePreference));
// Artists for song, both producers and vocalists
case "artist":
return(track.Song != null ? track.Song.ArtistString[languagePreference] : string.Empty);
case "track artist": // foobar style
return(track.Song != null ? track.Song.ArtistString[languagePreference] : string.Empty);
case "catalognum":
return(album.OriginalRelease != null ? album.OriginalRelease.CatNum : string.Empty);
case "disccount":
return((album.Songs.Any() ? album.Songs.Max(s => s.DiscNumber) : 0).ToString());
// Disc number
case "discnumber":
return(track.DiscNumber.ToString());
// List of vocalists, separated by comma, with "feat." in the beginning if there are any vocalists, otherwise empty.
case "featvocalists":
var vocalistStr = GetVocalistStr(track, languagePreference);
return(vocalistStr.Any() ? " feat. " + vocalistStr : string.Empty);
case "genres":
return(string.Join(", ", SongHelper.GetGenreTags(track).Select(t => t.NameWithSpaces)));
// List of producers
case "producers":
return(GetProducerStr(track, languagePreference));
// Album release date
case "releasedate":
return(track.Album.OriginalReleaseDate.ToString());
case "releaseyear":
return(track.Album.OriginalReleaseDate.Year.ToString());
case "releaseevent":
return(album.OriginalReleaseEventName);
// Song title
case "title":
return(track.Song != null ? track.Song.Names.SortNames[languagePreference] : track.Name);
case "totaltrackcount":
return(album.Songs.Count().ToString());
// Track number
case "track":
return(track.TrackNumber.ToString());
case "tracknumber": // foobar style
return(track.TrackNumber.ToString());
// List of vocalists, separated by comma.
case "vocalists":
return(GetVocalistStr(track, languagePreference));
default:
return(string.Empty);
}
}
private string GetAlbumMainProducersStr(Album album, ContentLanguagePreference languagePreference)
{
bool isAnimation = AlbumHelper.IsAnimation(album.DiscType);
return(ArtistHelper.GetArtistString(ArtistHelper.GetProducers(album.Artists.Where(a => !a.IsSupport), isAnimation), isAnimation)[languagePreference]);
}
// Only used for recent comments atm.
public EntryForApiContract(DiscussionTopic topic, ContentLanguagePreference languagePreference)
: this((IEntryWithNames)topic, languagePreference, EntryOptionalFields.None)
{
CreateDate = topic.Created;
}
public static IOrderedQueryable <T> OrderBySongName <T>(this IQueryable <T> query, ContentLanguagePreference languagePreference)
where T : ISongLink
{
switch (languagePreference)
{
case ContentLanguagePreference.Japanese:
return(query.OrderBy(e => e.Song.Names.SortNames.Japanese));
case ContentLanguagePreference.English:
return(query.OrderBy(e => e.Song.Names.SortNames.English));
default:
return(query.OrderBy(e => e.Song.Names.SortNames.Romaji));
}
}
public static IQueryable <T> OrderBy <T>(this IQueryable <T> query, SongSortRule sortRule, ContentLanguagePreference languagePreference)
where T : ISongLink
{
switch (sortRule)
{
case SongSortRule.Name:
return(query.OrderBySongName(languagePreference));
case SongSortRule.AdditionDate:
return(query.OrderByDescending(a => a.Song.CreateDate));
case SongSortRule.FavoritedTimes:
return(query.OrderByDescending(a => a.Song.FavoritedTimes));
case SongSortRule.RatingScore:
return(query.OrderByDescending(a => a.Song.RatingScore));
case SongSortRule.PublishDate:
return(query.OrderByDescending(a => a.Song.PublishDate.DateTime));
}
return(query);
}
public static IOrderedQueryable <T> AddNameOrder <T>(IQueryable <T> criteria, ContentLanguagePreference languagePreference) where T : IEntryWithNames
{
switch (languagePreference)
{
case ContentLanguagePreference.Japanese:
return(criteria.OrderBy(e => e.Names.SortNames.Japanese));
case ContentLanguagePreference.English:
return(criteria.OrderBy(e => e.Names.SortNames.English));
default:
return(criteria.OrderBy(e => e.Names.SortNames.Romaji));
}
}
public PVForSongContract(PVForSong pv, ContentLanguagePreference languagePreference)
: base(pv)
{
Song = new SongContract(pv.Song, languagePreference);
}
public ArtistSelectionForTrackContract(Artist artist, bool selected, ContentLanguagePreference languagePreference)
{
Artist = new ArtistContract(artist, languagePreference);
Selected = selected;
}
public static IQueryable <Song> OrderBy(this IQueryable <Song> criteria, SongSortRule sortRule, ContentLanguagePreference languagePreference)
{
return(AddOrder(criteria, sortRule, languagePreference));
}
public static IOrderedQueryable <T> AddNameOrder <T>(IOrderedQueryable <T> criteria, ContentLanguagePreference languagePreference) where T : IEntryWithNames
{
return(criteria.ThenBy(OrderByExpression <T>(languagePreference)));
}
public IEnumerable <RatedSongForUserForApiContract> GetRatings(int id, UserOptionalFields userFields,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
return(queries.GetRatings(id, userFields, lang));
}
public SongForApiContract GetById(int id, SongOptionalFields fields = SongOptionalFields.None, ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var song = queries.GetSongForApi(id, fields, lang);
return(song);
}
public static IQueryable <AlbumForUser> OrderBy(this IQueryable <AlbumForUser> query, AlbumSortRule sortRule, ContentLanguagePreference languagePreference)
{
switch (sortRule)
{
case AlbumSortRule.Name:
return(OrderByAlbumName(query, languagePreference));
case AlbumSortRule.CollectionCount:
return(query.OrderByDescending(a => a.Album.UserCollections.Count));
case AlbumSortRule.ReleaseDate:
return(query
.WhereHasReleaseDate()
.OrderByReleaseDate());
case AlbumSortRule.ReleaseDateWithNulls:
return(query.OrderByReleaseDate());
case AlbumSortRule.AdditionDate:
return(query.OrderByDescending(a => a.Album.CreateDate));
case AlbumSortRule.RatingAverage:
return(query.OrderByDescending(a => a.Album.RatingAverageInt)
.ThenByDescending(a => a.Album.RatingCount));
case AlbumSortRule.RatingTotal:
return(query.OrderByDescending(a => a.Album.RatingTotal)
.ThenByDescending(a => a.Album.RatingAverageInt));
case AlbumSortRule.NameThenReleaseDate:
return(OrderByAlbumName(query, languagePreference)
.ThenBy(a => a.Album.OriginalRelease.ReleaseDate.Year)
.ThenBy(a => a.Album.OriginalRelease.ReleaseDate.Month)
.ThenBy(a => a.Album.OriginalRelease.ReleaseDate.Day));
}
return(query);
}
public ArtistWithPictureContract(Artist artist, ContentLanguagePreference languagePreference)
: base(artist, languagePreference)
{
CoverPicture = (artist.Picture != null ? new PictureContract(artist.Picture, artist.PictureMime) : null);
}
public static EntryForPictureDisplayContract Create(IEntryWithNames entry, string mime, byte[] bytes, ContentLanguagePreference languagePreference)
{
var name = entry.Names.SortNames[languagePreference];
var pic = (bytes != null ? new PictureContract(bytes, mime) : null);
return(new EntryForPictureDisplayContract(entry.EntryType, entry.Id, name, entry.Version, pic));
}
public void OverrideLanguage(ContentLanguagePreference languagePreference)
{
OverrideLang = languagePreference;
}
protected override string GetFieldValue(string fieldName, SongInList songInList, ContentLanguagePreference languagePreference) => fieldName switch
{
"notes" => songInList.Notes,
public IEnumerable <SongForApiContract> GetTopSongs(
int?durationHours = null,
DateTime?startDate = null,
TopSongsDateFilterType?filterBy = null,
SongVocalistSelection?vocalist = null,
int maxResults = 25,
SongOptionalFields fields = SongOptionalFields.None,
ContentLanguagePreference languagePreference = ContentLanguagePreference.Default)
{
return(queries.HandleQuery(ctx => {
var query = ctx.Query()
.Where(s => !s.Deleted && s.RatingScore > 0)
.WhereHasVocalist(vocalist ?? SongVocalistSelection.Nothing);
if (durationHours.HasValue)
{
var timeSpan = TimeSpan.FromHours(durationHours.Value);
DateTime?endDate = null;
if (!startDate.HasValue)
{
startDate = DateTime.Now - timeSpan;
}
else
{
endDate = startDate + timeSpan;
}
switch (filterBy)
{
case TopSongsDateFilterType.PublishDate: {
startDate = startDate?.Date;
endDate = endDate?.Date;
query = query.WherePublishDateIsBetween(startDate, endDate);
break;
}
case TopSongsDateFilterType.CreateDate: {
query = query.Where(s => s.CreateDate >= startDate);
break;
}
case TopSongsDateFilterType.Popularity: {
// Sort by number of ratings and hits during that time
// Older songs get more hits so value them even less
query = query.OrderByDescending(s => s.UserFavorites
.Where(f => f.Date >= startDate)
.Sum(f => (int)f.Rating) + (s.Hits.Count(h => h.Date >= startDate) / 100));
break;
}
}
if (filterBy != TopSongsDateFilterType.Popularity)
{
query = query.OrderByDescending(s => s.RatingScore + (s.Hits.Count / 30));
}
}
else
{
query = query.OrderByDescending(s => s.RatingScore);
}
var songs = query
.Take(maxResults)
.ToArray();
var contracts = songs
.Select(s => new SongForApiContract(s, null, languagePreference, fields))
.ToArray();
return contracts;
}));
}
public static IQueryable <ReleaseEventSeries> OrderByName(this IQueryable <ReleaseEventSeries> query, ContentLanguagePreference languagePreference)
{
return(query.OrderByEntryName(languagePreference));
}
public static string ContentLanguagePreferenceName(ContentLanguagePreference languagePreference)
{
return(global::Resources.ContentLanguageSelectionNames.ResourceManager.GetString(languagePreference.ToString()));
}
