public PartialFindResult <ArtistForApiContract> GetList(
string query = "",
string artistTypes = null,
string tag = null,
int?followedByUserId = null,
EntryStatus?status = null,
int start = 0, int maxResults = defaultMax, bool getTotalCount = false,
ArtistSortRule sort = ArtistSortRule.Name,
bool preferAccurateMatches = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
ArtistOptionalFields fields = ArtistOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var textQuery = ArtistSearchTextQuery.Create(query, nameMatchMode);
var types = EnumVal <ArtistType> .ParseMultiple(artistTypes);
var param = new ArtistQueryParams(textQuery, types, start, Math.Min(maxResults, absoluteMax), false, getTotalCount, sort, preferAccurateMatches)
{
Tag = tag,
UserFollowerId = followedByUserId ?? 0
};
param.Common.EntryStatus = status;
var ssl = WebHelper.IsSSL(Request);
var artists = service.FindArtists(s => new ArtistForApiContract(s, lang, thumbPersister, ssl, fields), param);
return(artists);
}
public PartialFindResult <ArtistForUserForApiContract> GetFollowedArtists(
int id,
string query = "",
[FromUri] int[] tagId = null,
ArtistType artistType = ArtistType.Unknown,
int start = 0,
int maxResults = defaultMax,
bool getTotalCount = false,
ArtistSortRule sort = ArtistSortRule.Name,
NameMatchMode nameMatchMode = NameMatchMode.Auto,
ArtistOptionalFields fields = ArtistOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
maxResults = Math.Min(maxResults, absoluteMax);
var textQuery = ArtistSearchTextQuery.Create(query, nameMatchMode);
var queryParams = new FollowedArtistQueryParams {
UserId = id,
ArtistType = artistType,
Paging = new PagingProperties(start, maxResults, getTotalCount),
SortRule = sort,
TagIds = tagId,
TextQuery = textQuery
};
var artists = queries.GetArtists(queryParams, afu =>
new ArtistForUserForApiContract(afu, lang, thumbPersister, fields));
return(artists);
}
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 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(tagNames)
.Distinct()
.OrderBy(n => n)
.Take(maxResults)
.ToArray();
return NameHelper.MoveExactNamesToTop(allNames, textQuery.Query);
}));
}
public ArtistDetailsContract GetArtistDetails(string term)
{
var artists = artistService.FindArtists(new ArtistQueryParams(ArtistSearchTextQuery.Create(term), new ArtistType[] {}, 0, 10,
false, ArtistSortRule.Name, true));
if (!artists.Items.Any())
{
return(null);
}
return(artistQueries.GetDetails(artists.Items[0].Id));
}
public void Find_ByTwitter()
{
var result = artistSearch.Find(new ArtistQueryParams {
Common =
{
TextQuery = ArtistSearchTextQuery.Create("https://twitter.com/XenonP_XM")
}
});
Assert.AreEqual(1, result.Items.Length, "Got 1 result");
Assert.AreEqual("XenonP", result.Items[0].DefaultName, "Result as expected");
}
public void Find_ByTwitter_EndsWithP()
{
var artist = db.Save(CreateEntry.Artist(ArtistType.Producer, name: "Uji"));
db.SaveNames(artist);
db.Save(artist.CreateWebLink("Twitter", "https://twitter.com/Uji_RaychoruiP", WebLinkCategory.Official));
var result = artistSearch.Find(new ArtistQueryParams {
Common =
{
TextQuery = ArtistSearchTextQuery.Create("https://twitter.com/Uji_RaychoruiP")
}
});
Assert.AreEqual(1, result.Items.Length, "Got 1 result");
Assert.AreEqual("Uji", result.Items[0].DefaultName, "Result as expected");
}
public string[] FindNames(ArtistSearchTextQuery textQuery, int maxResults)
{
if (textQuery.IsEmpty)
{
return new string[] {}
}
;
return(HandleQuery(session => {
var names = session.Query <ArtistName>()
.Where(a => !a.Artist.Deleted)
.WhereArtistNameIs(textQuery)
.Select(n => n.Value)
.OrderBy(n => n)
.Distinct()
.Take(maxResults)
.ToArray();
return NameHelper.MoveExactNamesToTop(names, textQuery.Query);
}));
}
public ActionResult ByName(string query, ContentLanguagePreference?lang, int?start, int?maxResults, NameMatchMode?nameMatchMode,
string callback, DataFormat format = DataFormat.Auto)
{
if (string.IsNullOrEmpty(query))
{
return(Object(new PartialFindResult <SongForApiContract>(), format, callback));
}
var param = new ArtistQueryParams(ArtistSearchTextQuery.Create(query, nameMatchMode ?? NameMatchMode.Exact), new ArtistType[] { }, 0, defaultMax, false, true, ArtistSortRule.Name, false);
if (start.HasValue)
{
param.Paging.Start = start.Value;
}
if (maxResults.HasValue)
{
param.Paging.MaxEntries = Math.Min(maxResults.Value, defaultMax);
}
var songs = Service.FindArtists(s => new ArtistForApiContractOld(s, null, lang ?? ContentLanguagePreference.Default), param);
return(Object(songs, format, callback));
}
public PartialFindResult <ArtistForApiContract> GetList(
string query = "",
string artistTypes = null,
bool allowBaseVoicebanks = true,
[FromQuery(Name = "tagName[]")] string[] tagName = null,
[FromQuery(Name = "tagId[]")] int[] tagId = null,
bool childTags = false,
int?followedByUserId = null,
EntryStatus?status = null,
[FromQuery(Name = "advancedFilters")] AdvancedSearchFilterParams[] advancedFilters = null,
int start = 0, int maxResults = DefaultMax, bool getTotalCount = false,
ArtistSortRule sort = ArtistSortRule.Name,
bool preferAccurateMatches = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
ArtistOptionalFields fields = ArtistOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default)
{
var textQuery = ArtistSearchTextQuery.Create(query, nameMatchMode);
var types = EnumVal <ArtistType> .ParseMultiple(artistTypes);
var param = new ArtistQueryParams(textQuery, types, start, Math.Min(maxResults, AbsoluteMax), getTotalCount, sort, preferAccurateMatches)
{
Tags = tagName,
TagIds = tagId,
ChildTags = childTags,
UserFollowerId = followedByUserId ?? 0,
AllowBaseVoicebanks = allowBaseVoicebanks,
AdvancedFilters = advancedFilters?.Select(advancedFilter => advancedFilter.ToAdvancedSearchFilter()).ToArray(),
};
param.Common.EntryStatus = status;
var artists = _service.FindArtists(s => new ArtistForApiContract(s, lang, _thumbPersister, fields), param);
return(artists);
}
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 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);
}
public AllEntriesSearchResult Find(string query, int maxResults, bool getTotalCount)
{
if (string.IsNullOrWhiteSpace(query))
{
return(new AllEntriesSearchResult());
}
var textQuery = SearchTextQuery.Create(query);
var artistTextQuery = ArtistSearchTextQuery.Create(query, textQuery.MatchMode); // Can't use the existing words collection here as they are noncanonized
var tagTextQuery = TagSearchTextQuery.Create(query, textQuery.MatchMode);
return(HandleQuery(session => {
var artists =
session.Query <ArtistName>()
.FilterByArtistName(artistTextQuery)
.Where(a => !a.Artist.Deleted)
.Select(n => n.Artist)
.AddNameOrder(LanguagePreference)
.Distinct()
.Take(maxResults)
.ToArray();
var artistCount = (getTotalCount ?
session.Query <ArtistName>()
.FilterByArtistName(artistTextQuery)
.Where(a => !a.Artist.Deleted)
.Select(n => n.Artist)
.Distinct()
.Count()
: 0);
var albums =
session.Query <AlbumName>()
.AddEntryNameFilter(textQuery)
.Where(a => !a.Album.Deleted)
.Select(n => n.Album)
.AddNameOrder(LanguagePreference)
.Distinct()
.Take(maxResults)
.ToArray();
var albumCount = (getTotalCount ?
session.Query <AlbumName>()
.AddEntryNameFilter(textQuery)
.Where(a => !a.Album.Deleted)
.Select(n => n.Album)
.Distinct()
.Count()
: 0);
var songs =
session.Query <SongName>()
.AddEntryNameFilter(textQuery)
.Where(a => !a.Song.Deleted)
.Select(n => n.Song)
.AddNameOrder(LanguagePreference)
.Distinct()
.Take(maxResults)
.ToArray();
var songCount = (getTotalCount ?
session.Query <SongName>()
.AddEntryNameFilter(textQuery)
.Where(a => !a.Song.Deleted)
.Select(n => n.Song)
.Distinct()
.Count()
: 0);
var tags = session.Query <Tag>()
.AddTagNameFilter(tagTextQuery)
.OrderBy(t => t.Name)
.Take(maxResults)
.ToArray();
var tagCount = (getTotalCount ? session.Query <Tag>()
.AddTagNameFilter(tagTextQuery)
.Distinct()
.Count()
: 0);
var artistResult = new PartialFindResult <ArtistContract>(
artists.Select(a => new ArtistContract(a, PermissionContext.LanguagePreference)).ToArray(), artistCount);
var albumResult = new PartialFindResult <AlbumContract>(
albums.Select(a => new AlbumContract(a, PermissionContext.LanguagePreference)).ToArray(), albumCount);
var songResult = new PartialFindResult <SongWithAlbumContract>(
songs.Select(a => new SongWithAlbumContract(a, PermissionContext.LanguagePreference)).ToArray(), songCount);
var tagResult = new PartialFindResult <TagContract>(
tags.Select(a => new TagContract(a)).ToArray(), tagCount);
return new AllEntriesSearchResult(query, albumResult, artistResult, songResult, tagResult);
}));
}
private IQueryable <ArtistName> FilterByArtistName(string artistName)
{
return(artists.AsQueryable().FilterByArtistName(ArtistSearchTextQuery.Create(artistName)));
}
public static IQueryable <T> WhereArtistHasName <T>(this IQueryable <T> query, ArtistSearchTextQuery textQuery) where T : IArtistLink
{
if (textQuery == null || textQuery.IsEmpty)
{
return(query);
}
var nameFilter = textQuery.Query;
switch (textQuery.MatchMode)
{
case NameMatchMode.Exact:
return(query.Where(m => m.Artist.Names.Names.Any(n => n.Value == nameFilter)));
case NameMatchMode.Partial:
return(query.Where(m => m.Artist.Names.Names.Any(n => n.Value.Contains(nameFilter))));
case NameMatchMode.StartsWith:
return(query.Where(m => m.Artist.Names.Names.Any(n => n.Value.StartsWith(nameFilter))));
case NameMatchMode.Words:
return(textQuery.Words
.Take(FindHelpers.MaxSearchWords)
.Aggregate(query, (q, word) => q.Where(link => link.Artist.Names.Names.Any(n => n.Value.Contains(word)))));
}
return(query);
}
/// <summary>
/// Filters query by canonized artist name.
/// This means that any P suffixes are ignored.
/// </summary>
/// <param name="query">Artist query. Cannot be null.</param>
/// <param name="textQuery">Textual filter. Cannot be null.</param>
/// <returns>Filtered query. Cannot be null.</returns>
public static IQueryable <Artist> WhereHasName_Canonized(this IQueryable <Artist> query, ArtistSearchTextQuery textQuery)
{
if (textQuery.IsEmpty)
{
return(query);
}
var canonizedName = textQuery.Query;
if (textQuery.IsExact)
{
return(query.Where(m => m.Names.Names.Any(n =>
n.Value == canonizedName ||
n.Value == string.Format("{0}P", canonizedName) ||
n.Value == string.Format("{0}-P", canonizedName))));
}
else
{
return(query.WhereHasName(textQuery));
}
}
public string[] GetNames(string query = "", NameMatchMode nameMatchMode = NameMatchMode.Auto, int maxResults = 15) => _service.FindNames(ArtistSearchTextQuery.Create(query, nameMatchMode), maxResults);
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, 0, 1, true, EntrySortRule.Name,
NameMatchMode.Auto, Model.DataContracts.Api.EntryOptionalFields.None, Model.Domain.Globalization.ContentLanguagePreference.Default, false, true);
if (result.TotalCount == 1)
{
var item = result.Items.First();
var entryType = item.EntryType;
var entryId = item.Id;
if (entryType == EntryType.Album)
{
return(RedirectToAlbum(entryId));
}
if (entryType == EntryType.Artist)
{
return(RedirectToArtist(entryId));
}
if (entryType == EntryType.Song)
{
return(RedirectToSong(entryId));
}
if (entryType == 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));
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));
if (album.Items.Length == 1)
{
return(RedirectToAlbum(album.Items[0].Id));
}
break;
case EntryType.ReleaseEvent:
var ev = eventQueries.Find(s => s.Id, textQuery, 0, null, null, 0, 2, false, EventSortRule.Name);
if (ev.Items.Length == 1)
{
return(RedirectToReleaseEvent(ev.Items[0]));
}
return(RedirectToAction("EventsBySeries", "Event"));
case EntryType.Song:
var song = songService.Find(new SongQueryParams(textQuery, null, 0, 2, false, SongSortRule.None, false, false, null));
if (song.Items.Length == 1)
{
return(RedirectToSong(song.Items[0].Id));
}
break;
case EntryType.SongList:
var list = songListQueries.Find(s => s.Id, textQuery, null, 0, 2, false, 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)),
TagOptionalFields.None, WebHelper.IsSSL(Request), 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);
}
public static IQueryable <ArtistName> WhereArtistNameIs(this IQueryable <ArtistName> query, ArtistSearchTextQuery textQuery)
{
var canonizedName = textQuery.Query;
if (textQuery.IsExact)
{
return(query.Where(m => m.Value == canonizedName ||
m.Value == $"{canonizedName}P" ||
m.Value == $"{canonizedName}-P"));
}
else
{
return(query.WhereEntryNameIs(textQuery));
}
}
// TODO: should be combined with common name query somehow, but NH is making it hard
/// <summary>
/// Filters an artist query by a name query.
/// </summary>
/// <param name="query">Artist query. Cannot be null.</param>
/// <param name="nameFilter">Name filter string. If null or empty, no filtering is done.</param>
/// <param name="matchMode">Desired mode for matching names.</param>
/// <param name="words">
/// List of words for the words search mode.
/// Can be null, in which case the words list will be parsed from <paramref name="nameFilter"/>.
/// </param>
/// <returns>Filtered query. Cannot be null.</returns>
public static IQueryable <Artist> WhereHasName(this IQueryable <Artist> query, ArtistSearchTextQuery textQuery)
{
if (textQuery.IsEmpty)
{
return(query);
}
var nameFilter = textQuery.Query;
switch (textQuery.MatchMode)
{
case NameMatchMode.Exact:
return(query.Where(m => m.Names.Names.Any(n => n.Value == nameFilter)));
case NameMatchMode.Partial:
return(query.Where(m => m.Names.Names.Any(n => n.Value.Contains(nameFilter))));
case NameMatchMode.StartsWith:
return(query.Where(m => m.Names.Names.Any(n => n.Value.StartsWith(nameFilter))));
case NameMatchMode.Words:
var words = textQuery.Words;
switch (words.Length)
{
case 1:
query = query.Where(q => q.Names.Names.Any(n => n.Value.Contains(words[0])));
break;
case 2:
query = query.Where(q =>
q.Names.Names.Any(n => n.Value.Contains(words[0])) &&
q.Names.Names.Any(n => n.Value.Contains(words[1]))
);
break;
case 3:
query = query.Where(q =>
q.Names.Names.Any(n => n.Value.Contains(words[0])) &&
q.Names.Names.Any(n => n.Value.Contains(words[1])) &&
q.Names.Names.Any(n => n.Value.Contains(words[2]))
);
break;
case 4:
query = query.Where(q =>
q.Names.Names.Any(n => n.Value.Contains(words[0])) &&
q.Names.Names.Any(n => n.Value.Contains(words[1])) &&
q.Names.Names.Any(n => n.Value.Contains(words[2])) &&
q.Names.Names.Any(n => n.Value.Contains(words[3]))
);
break;
case 5:
query = query.Where(q =>
q.Names.Names.Any(n => n.Value.Contains(words[0])) &&
q.Names.Names.Any(n => n.Value.Contains(words[1])) &&
q.Names.Names.Any(n => n.Value.Contains(words[2])) &&
q.Names.Names.Any(n => n.Value.Contains(words[3])) &&
q.Names.Names.Any(n => n.Value.Contains(words[4]))
);
break;
case 6:
query = query.Where(q =>
q.Names.Names.Any(n => n.Value.Contains(words[0])) &&
q.Names.Names.Any(n => n.Value.Contains(words[1])) &&
q.Names.Names.Any(n => n.Value.Contains(words[2])) &&
q.Names.Names.Any(n => n.Value.Contains(words[3])) &&
q.Names.Names.Any(n => n.Value.Contains(words[4])) &&
q.Names.Names.Any(n => n.Value.Contains(words[5]))
);
break;
}
return(query);
}
return(query);
}
/// <summary>
/// Filters an artist query by a name query.
/// </summary>
/// <param name="query">Artist query. Cannot be null.</param>
/// <param name="textQuery">Textual filter. Cannot be null.</param>
/// <returns>Filtered query. Cannot be null.</returns>
public static IQueryable <Artist> WhereHasName(this IQueryable <Artist> query, ArtistSearchTextQuery textQuery)
{
return(query.WhereHasNameGeneric <Artist, ArtistName>(textQuery));
}
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 ssl,
bool searchTags = 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)
.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 tagQuery = searchTags ? ctx.OfType <Tag>().Query()
.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])
.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];
// 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];
var searchedTags = searchTags && searchedTagIds.Any() ? ctx.OfType <Tag>().Query()
.Where(a => searchedTagIds.Contains(a.Id))
.ToArray()
.Select(a => new EntryForApiContract(a, lang, entryImagePersisterOld, ssl, fields)) : new EntryForApiContract[0];
// Merge and sort the final list
var entries = artists.Concat(albums).Concat(songs).Concat(searchedTags);
if (sort == EntrySortRule.Name)
{
entries = entries.OrderBy(a => a.Name);
}
if (sort == EntrySortRule.AdditionDate)
{
entries = entries.OrderByDescending(a => a.CreateDate);
}
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;
count = artistCount + albumCount + songCount + tagCount;
}
return new PartialFindResult <EntryForApiContract>(entries.ToArray(), count);
}));
}
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;
}));
}
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);
}
public static IQueryable <ArtistName> WhereArtistNameIs(this IQueryable <ArtistName> query, ArtistSearchTextQuery textQuery)
{
var canonizedName = textQuery.Query;
if (textQuery.IsExact)
{
return(query.Where(m => m.Value == canonizedName ||
m.Value == string.Format("{0}P", canonizedName) ||
m.Value == string.Format("{0}-P", canonizedName)));
}
else
{
return(FindHelpers.AddEntryNameFilter(query, textQuery));
}
}
