public SongDetailsContract XGetSongByNameArtistAndAlbum(string name, string artist, string album)
{
return(HandleQuery(session => {
var matches = session.Query <SongName>().Where(n => n.Value == name)
.Select(n => n.Song)
.ToArray();
Artist[] artists = null;
if (!string.IsNullOrEmpty(artist))
{
artists = session.Query <ArtistName>()
.WhereArtistNameIs(ArtistSearchTextQuery.Create(artist))
.Select(n => n.Artist)
.Take(10)
.ToArray();
}
if (artists != null && artists.Any())
{
matches = matches.Where(s => s.ArtistList.Any(a => artists.Contains(a))).ToArray();
}
Album[] albums = null;
if (!string.IsNullOrEmpty(album))
{
albums = session.Query <Album>()
.WhereHasName(SearchTextQuery.Create(album))
.Take(10)
.ToArray();
}
if (albums != null && albums.Any())
{
matches = matches.Where(s => s.Albums.Any(a => albums.Contains(a.Album))).ToArray();
}
if (matches.Length == 1)
{
return new SongDetailsContract(matches.First(), PermissionContext.LanguagePreference, new SongListBaseContract[0], null, null, PermissionContext, null);
}
if (matches.Length == 0)
{
return null;
}
matches = session.Query <SongName>()
.WhereEntryNameIs(SearchTextQuery.Create(name))
.Select(n => n.Song)
.ToArray();
if (artists != null && artists.Any())
{
matches = matches.Where(s => s.ArtistList.Any(a => artists.Contains(a))).ToArray();
}
if (albums != null && albums.Any())
{
matches = matches.Where(s => s.Albums.Any(a => albums.Contains(a.Album))).ToArray();
}
if (matches.Length == 1)
{
return new SongDetailsContract(matches.First(), PermissionContext.LanguagePreference, new SongListBaseContract[0], null, null, PermissionContext, null);
}
return null;
}));
}
public string[] FindNames(SearchTextQuery textQuery, int maxResults)
{
if (textQuery.IsEmpty)
{
return new string[] {}
}
;
var artistTextQuery = ArtistSearchTextQuery.Create(textQuery);
var tagTextQuery = TagSearchTextQuery.Create(textQuery);
return(HandleQuery(session => {
var artistNames = session.Query <ArtistName>()
.WhereArtistNameIs(artistTextQuery)
.Where(a => !a.Artist.Deleted)
.Select(n => n.Value)
.OrderBy(n => n)
.Distinct()
.Take(maxResults)
.ToArray();
var albumNames = session.Query <AlbumName>()
.WhereEntryNameIs(textQuery)
.Where(a => !a.Album.Deleted)
.Select(n => n.Value)
.OrderBy(n => n)
.Distinct()
.Take(maxResults)
.ToArray();
var songNames = session.Query <SongName>()
.WhereEntryNameIs(textQuery)
.Where(a => !a.Song.Deleted)
.Select(n => n.Value)
.OrderBy(n => n)
.Distinct()
.Take(maxResults)
.ToArray();
var eventNames = session.Query <EventName>()
.WhereEntryNameIs(tagTextQuery)
.Where(a => !a.Entry.Deleted)
.Select(t => t.Value)
.OrderBy(t => t)
.Take(maxResults)
.ToArray();
var tagNames = session.Query <TagName>()
.WhereEntryNameIs(tagTextQuery)
.Where(a => !a.Entry.Deleted)
.Select(t => t.Value)
.OrderBy(t => t)
.Take(maxResults)
.ToArray();
var allNames = artistNames
.Concat(albumNames)
.Concat(songNames)
.Concat(eventNames)
.Concat(tagNames)
.Distinct()
.OrderBy(n => n)
.Take(maxResults)
.ToArray();
return NameHelper.MoveExactNamesToTop(allNames, textQuery.Query);
}));
}
public string[] GetNames(string query = "", NameMatchMode nameMatchMode = NameMatchMode.Auto, int maxResults = 15)
{
return(service.FindNames(ArtistSearchTextQuery.Create(query, nameMatchMode), maxResults));
}
public PartialFindResult <ArtistContract> FindArtists(string term, int maxResults, NameMatchMode nameMatchMode = NameMatchMode.Auto)
{
return(artistService.FindArtists(new ArtistQueryParams(ArtistSearchTextQuery.Create(term, nameMatchMode), new ArtistType[] {}, 0, maxResults, true, ArtistSortRule.Name, true)));
}
private IQueryable <ArtistName> FilterByArtistName(string artistName)
{
return(artists.AsQueryable().WhereArtistNameIs(ArtistSearchTextQuery.Create(artistName)));
}
public PartialFindResult <EntryForApiContract> GetList(
string query,
int[] tagIds,
string[] tags,
bool childTags,
EntryStatus?status,
int start, int maxResults, bool getTotalCount,
EntrySortRule sort,
NameMatchMode nameMatchMode,
EntryOptionalFields fields,
ContentLanguagePreference lang,
bool searchTags = false,
bool searchEvents = false
)
{
var textQuery = SearchTextQuery.Create(query, nameMatchMode);
var artistTextQuery = ArtistSearchTextQuery.Create(query, nameMatchMode); // Can't use the existing words collection here as they are noncanonized
return(repository.HandleQuery(ctx => {
// Get all applicable names per entry type
var artistQuery = ctx.OfType <Artist>().Query()
.Where(a => !a.Deleted)
.WhereHasName_Canonized(artistTextQuery)
.WhereHasTags(tagIds, childTags)
.WhereHasTags(tags)
.WhereStatusIs(status);
var artistNames = artistQuery
.OrderBy(sort, lang)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.Artist)
.ToArray();
var albumQuery = ctx.OfType <Album>().Query()
.Where(a => !a.Deleted)
.WhereHasName(textQuery)
.WhereHasTags(tagIds, childTags)
.WhereHasTags(tags)
.WhereStatusIs(status);
var albumNames = albumQuery
.OrderBy(sort, lang, null)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.Album)
.ToArray();
var songQuery = ctx.OfType <Song>().Query()
.Where(a => !a.Deleted)
.WhereHasName(textQuery)
.WhereHasTags(tagIds, childTags)
.WhereHasTags(tags)
.WhereStatusIs(status);
var songNames = songQuery
.OrderBy(sort, lang)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.Song)
.ToArray();
var eventQuery = searchEvents ? ctx.OfType <ReleaseEvent>().Query()
.WhereNotDeleted()
.WhereHasName(textQuery)
.WhereHasTags(tagIds, childTags)
.WhereStatusIs(status) : null;
var eventNames = searchEvents ? eventQuery
.OrderBy(sort, lang, null)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.ReleaseEvent)
.ToArray() : null;
var tagQuery = searchTags ? ctx.OfType <Tag>().Query()
.WhereNotDeleted()
.WhereHasName(textQuery)
.WhereStatusIs(status) : null;
var tagNames = searchTags ? tagQuery
.OrderBy(sort, lang)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.Tag)
.ToArray() : null;
// Get page of combined names
var entryNames = artistNames
.Concat(albumNames)
.Concat(songNames)
.Concat(tagNames ?? new DataContracts.EntryBaseContract[0])
.Concat(eventNames ?? new DataContracts.EntryBaseContract[0])
.OrderBy(e => e.DefaultName)
.Skip(start)
.Take(maxResults)
.ToArray();
var artistIds = entryNames.Where(e => e.EntryType == EntryType.Artist).Select(a => a.Id).ToArray();
var albumIds = entryNames.Where(e => e.EntryType == EntryType.Album).Select(a => a.Id).ToArray();
var songIds = entryNames.Where(e => e.EntryType == EntryType.Song).Select(a => a.Id).ToArray();
var searchedTagIds = searchTags ? entryNames.Where(e => e.EntryType == EntryType.Tag).Select(a => a.Id).ToArray() : new int[0];
var eventIds = searchEvents ? entryNames.Where(e => e.EntryType == EntryType.ReleaseEvent).Select(a => a.Id).ToArray() : new int[0];
// Get the actual entries in the page
var artists = artistIds.Any() ? ctx.OfType <Artist>().Query()
.Where(a => artistIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, entryThumbPersister, fields)) : new EntryForApiContract[0];
var albums = albumIds.Any() ? ctx.OfType <Album>().Query()
.Where(a => albumIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, entryThumbPersister, fields)) : new EntryForApiContract[0];
var songs = songIds.Any() ? ctx.OfType <Song>().Query()
.Where(a => songIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, fields)) : new EntryForApiContract[0];
var searchedTags = searchTags && searchedTagIds.Any() ? ctx.OfType <Tag>().Query()
.Where(a => searchedTagIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, entryImagePersisterOld, fields)) : new EntryForApiContract[0];
var events = searchEvents && eventIds.Any() ? ctx.OfType <ReleaseEvent>().Query()
.Where(a => eventIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, entryThumbPersister, fields)) : new EntryForApiContract[0];
// Merge and sort the final list
var entries = artists.Concat(albums).Concat(songs).Concat(searchedTags).Concat(events);
if (sort == EntrySortRule.Name)
{
entries = entries.OrderBy(a => a.Name);
}
if (sort == EntrySortRule.AdditionDate)
{
entries = entries.OrderByDescending(a => a.CreateDate);
}
if (sort == EntrySortRule.ActivityDate)
{
entries = entries.OrderByDescending(a => a.ActivityDate);
}
var count = 0;
if (getTotalCount)
{
var artistCount =
(artistNames.Length >= maxResults ? artistQuery.Count() : artistNames.Length);
var albumCount =
(albumNames.Length >= maxResults ? albumQuery.Count() : albumNames.Length);
var songCount =
(songNames.Length >= maxResults ? songQuery.Count() : songNames.Length);
var tagCount =
searchTags ? (tagNames.Length >= maxResults ? tagQuery.Count() : tagNames.Length) : 0;
var eventCount =
searchEvents ? (eventNames.Length >= maxResults ? eventQuery.Count() : eventNames.Length) : 0;
count = artistCount + albumCount + songCount + tagCount + eventCount;
}
return new PartialFindResult <EntryForApiContract>(entries.ToArray(), count);
}));
}
public PartialFindResult <EntryForApiContract> GetList(
string query,
string tag,
EntryStatus?status,
int start, int maxResults, bool getTotalCount,
NameMatchMode nameMatchMode,
EntryOptionalFields fields,
ContentLanguagePreference lang,
bool ssl
)
{
var textQuery = SearchTextQuery.Create(query, nameMatchMode);
var artistTextQuery = ArtistSearchTextQuery.Create(query, textQuery.MatchMode); // Can't use the existing words collection here as they are noncanonized
return(repository.HandleQuery(ctx => {
// Get all applicable names per entry type
var artistNames = ctx.OfType <Artist>().Query()
.Where(a => !a.Deleted)
.WhereHasName_Canonized(artistTextQuery)
.WhereHasTag(tag)
.WhereStatusIs(status)
.OrderBy(ArtistSortRule.Name, lang)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.Artist)
.ToArray();
var albumNames = ctx.OfType <Album>().Query()
.Where(a => !a.Deleted)
.WhereHasName(textQuery)
.WhereHasTag(tag)
.WhereStatusIs(status)
.OrderBy(AlbumSortRule.Name, lang)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.Album)
.ToArray();
var songNames = ctx.OfType <Song>().Query()
.Where(a => !a.Deleted)
.WhereHasName(textQuery)
.WhereHasTag(tag)
.WhereStatusIs(status)
.OrderBy(SongSortRule.Name, lang)
.Take(start + maxResults)
.SelectEntryBase(lang, EntryType.Song)
.ToArray();
// Get page of combined names
var entryNames = artistNames.Concat(albumNames).Concat(songNames)
.OrderBy(e => e.DefaultName)
.Skip(start)
.Take(maxResults)
.ToArray();
var artistIds = entryNames.Where(e => e.EntryType == EntryType.Artist).Select(a => a.Id).ToArray();
var albumIds = entryNames.Where(e => e.EntryType == EntryType.Album).Select(a => a.Id).ToArray();
var songIds = entryNames.Where(e => e.EntryType == EntryType.Song).Select(a => a.Id).ToArray();
// Get the actual entries in the page
var artists = artistIds.Any() ? ctx.OfType <Artist>().Query()
.Where(a => artistIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, entryThumbPersister, ssl, fields)) : new EntryForApiContract[0];
var albums = albumIds.Any() ? ctx.OfType <Album>().Query()
.Where(a => albumIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, entryThumbPersister, ssl, fields)) : new EntryForApiContract[0];
var songs = songIds.Any() ? ctx.OfType <Song>().Query()
.Where(a => songIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, fields)) : new EntryForApiContract[0];
// Merge and sort the final list
var entries = artists.Concat(albums).Concat(songs)
.OrderBy(a => a.Name);
var count = 0;
if (getTotalCount)
{
count =
ctx.OfType <Artist>().Query()
.Where(a => !a.Deleted)
.WhereHasName_Canonized(artistTextQuery)
.WhereHasTag(tag)
.WhereStatusIs(status)
.Count() +
ctx.OfType <Album>().Query()
.Where(a => !a.Deleted)
.WhereHasName(textQuery)
.WhereHasTag(tag)
.WhereStatusIs(status)
.Count() +
ctx.OfType <Song>().Query()
.Where(a => !a.Deleted)
.WhereHasName(textQuery)
.WhereHasTag(tag)
.WhereStatusIs(status)
.Count();
}
return new PartialFindResult <EntryForApiContract>(entries.ToArray(), count);
}));
}
private ActionResult TryRedirect(string filter, EntryType searchType)
{
var textQuery = SearchTextQuery.Create(filter);
var artistTextQuery = ArtistSearchTextQuery.Create(filter);
switch (searchType)
{
case EntryType.Undefined:
{
var result = _entryQueries.GetList(filter, null, null, false, null, null, 0, 1, true, EntrySortRule.Name,
NameMatchMode.Auto, Model.DataContracts.Api.EntryOptionalFields.None, Model.Domain.Globalization.ContentLanguagePreference.Default,
searchTags: true, searchEvents: true);
if (result.TotalCount == 1)
{
var item = result.Items.First();
var entryId = item.Id;
switch (item.EntryType)
{
case EntryType.Album:
return(RedirectToAlbum(entryId));
case EntryType.Artist:
return(RedirectToArtist(entryId));
case EntryType.ReleaseEvent:
return(RedirectToReleaseEvent(entryId, item.UrlSlug));
case EntryType.Song:
return(RedirectToSong(entryId));
case EntryType.Tag:
return(RedirectToTag(entryId, item.UrlSlug));
}
}
}
break;
case EntryType.Artist:
var artist = _artistService.FindArtists(new ArtistQueryParams(artistTextQuery, null, 0, 2, false, ArtistSortRule.None, false)
{
LanguagePreference = PermissionContext.LanguagePreference
});
if (artist.Items.Length == 1)
{
return(RedirectToArtist(artist.Items[0].Id));
}
break;
case EntryType.Album:
var album = _albumService.Find(new AlbumQueryParams(textQuery, DiscType.Unknown, 0, 2, false, AlbumSortRule.None, false)
{
LanguagePreference = PermissionContext.LanguagePreference
});
if (album.Items.Length == 1)
{
return(RedirectToAlbum(album.Items[0].Id));
}
break;
case EntryType.ReleaseEvent:
var queryParams = new EventQueryParams
{
TextQuery = textQuery,
Paging = new PagingProperties(0, 2, false)
};
var ev = _eventQueries.Find(s => new { s.Id, s.UrlSlug }, queryParams);
if (ev.Items.Length == 1)
{
return(RedirectToReleaseEvent(ev.Items[0].Id, ev.Items[0].UrlSlug));
}
break;
case EntryType.Song:
var song = _songService.Find(new SongQueryParams(textQuery, null, 0, 2, false, SongSortRule.None, false, false, null)
{
LanguagePreference = PermissionContext.LanguagePreference
});
if (song.Items.Length == 1)
{
return(RedirectToSong(song.Items[0].Id));
}
break;
case EntryType.SongList:
var list = _songListQueries.Find(s => s.Id, new SongListQueryParams {
TextQuery = textQuery, Paging = new PagingProperties(0, 2, false), SortRule = SongListSortRule.Name
});
if (list.Items.Length == 1)
{
return(RedirectToSongList(list.Items[0]));
}
return(RedirectToAction("Featured", "SongList"));
case EntryType.Tag:
var tags = _tagQueries.Find(new TagQueryParams(new CommonSearchParams(textQuery, true, true), PagingProperties.FirstPage(2))
{
AllowChildren = true,
LanguagePreference = PermissionContext.LanguagePreference
}, TagOptionalFields.None, _permissionContext.LanguagePreference);
if (tags.Items.Length == 1)
{
return(RedirectToTag(tags.Items.First().Id, tags.Items.First().Name));
}
break;
default:
{
var action = "Index";
var controller = searchType.ToString();
return(RedirectToAction(action, controller, new { filter }));
}
}
return(null);
}
private ActionResult TryRedirect(string filter, EntryType searchType)
{
var textQuery = SearchTextQuery.Create(filter);
var artistTextQuery = ArtistSearchTextQuery.Create(filter);
switch (searchType)
{
case EntryType.Undefined: {
var result = services.Find(filter, 1, true);
if (result.OnlyOneItem)
{
if (result.Albums.TotalCount == 1)
{
return(RedirectToAlbum(result.Albums.Items[0].Id));
}
if (result.Artists.TotalCount == 1)
{
return(RedirectToArtist(result.Artists.Items[0].Id));
}
if (result.Songs.TotalCount == 1)
{
return(RedirectToSong(result.Songs.Items[0].Id));
}
if (result.Tags.TotalCount == 1)
{
return(RedirectToAction("Details", "Tag", new { id = result.Tags.Items[0].Name }));
}
}
}
break;
case EntryType.Artist:
var artist = artistService.FindArtists(new ArtistQueryParams(artistTextQuery, null, 0, 2, false, false, ArtistSortRule.None, false));
if (artist.Items.Length == 1)
{
return(RedirectToArtist(artist.Items[0].Id));
}
break;
case EntryType.Album:
var album = albumService.Find(new AlbumQueryParams(textQuery, DiscType.Unknown, 0, 2, false, false, AlbumSortRule.None, false));
if (album.Items.Length == 1)
{
return(RedirectToAlbum(album.Items[0].Id));
}
break;
case EntryType.Song:
var song = songService.Find(new SongQueryParams(textQuery, null, 0, 2, false, false, SongSortRule.None, false, false, null));
if (song.Items.Length == 1)
{
return(RedirectToSong(song.Items[0].Id));
}
break;
default: {
var action = "Index";
var controller = searchType.ToString();
return(RedirectToAction(action, controller, new { filter }));
}
}
return(null);
}