public PartialFindResult <T> Find <T>(Func <Tag, T> fac, CommonSearchParams queryParams, PagingProperties paging,
bool allowAliases = false, string categoryName = "")
where T : class
{
var textQuery = TagSearchTextQuery.Create(queryParams.Query, queryParams.NameMatchMode);
return(HandleQuery(ctx => {
var query = ctx.Query()
.WhereHasName(textQuery)
.WhereAllowAliases(allowAliases)
.WhereHasCategoryName(categoryName);
var tags = query
.OrderBy(t => t.Name)
.Skip(paging.Start)
.Take(paging.MaxEntries)
.ToArray();
var count = 0;
if (paging.GetTotalCount)
{
count = query.Count();
}
var result = tags.Select(fac).ToArray();
return new PartialFindResult <T>(result, count, queryParams.Query, false);
}));
}
public PartialFindResult <TagForApiContract> GetList(
string query = "",
bool allowChildren = true,
string categoryName = "",
int start = 0, int maxResults = DefaultMax, bool getTotalCount = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
TagSortRule?sort = null,
bool preferAccurateMatches = false,
TagOptionalFields fields = TagOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default,
TagTargetTypes target = TagTargetTypes.All)
{
maxResults = Math.Min(maxResults, fields != TagOptionalFields.None ? AbsoluteMax : int.MaxValue);
var queryParams = new TagQueryParams(new CommonSearchParams(TagSearchTextQuery.Create(query, nameMatchMode), false, preferAccurateMatches),
new PagingProperties(start, maxResults, getTotalCount))
{
AllowChildren = allowChildren,
CategoryName = categoryName,
SortRule = sort ?? TagSortRule.Name,
LanguagePreference = lang,
Target = target
};
var tags = _queries.Find(queryParams, fields, lang);
return(tags);
}
public string[] FindNames(TagSearchTextQuery textQuery, bool allowAliases, bool allowEmptyName, int maxEntries)
{
if (!allowEmptyName && textQuery.IsEmpty)
{
return new string[] { }
}
;
return(HandleQuery(session => {
var q = session.Query()
.WhereHasName(textQuery);
if (!allowAliases)
{
q = q.Where(t => t.AliasedTo == null);
}
var tags = q
.OrderBy(t => t.Name)
.Take(maxEntries)
.Select(t => t.Name)
.ToArray();
return tags;
}));
}
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);
}));
}
private Tag GetTagByName(IDatabaseContext <Tag> ctx, string name)
{
var tag = ctx.Query().WhereHasName(TagSearchTextQuery.Create(name, NameMatchMode.Exact)).FirstOrDefault();
if (tag == null)
{
log.Warn("Tag not found: {0}", name);
}
return(tag);
}
public string[] FindNames(TagSearchTextQuery textQuery, bool allowAliases, int maxEntries)
{
return(HandleQuery(session => {
var q = session.Query <TagName>()
.Where(t => !t.Entry.Deleted)
.WhereEntryNameIs(textQuery);
var tags = q
.Select(t => t.Value)
.OrderBy(t => t)
.Take(maxEntries)
.ToArray();
return tags;
}));
}
public PartialFindResult <TagForApiContract> GetList(
string query = "",
bool allowAliases = false,
string categoryName = "",
int start = 0, int maxResults = defaultMax, bool getTotalCount = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
TagOptionalFields fields = TagOptionalFields.None)
{
maxResults = Math.Min(maxResults, absoluteMax);
var ssl = WebHelper.IsSSL(Request);
var queryParams = new CommonSearchParams(TagSearchTextQuery.Create(query, nameMatchMode), false, false, false);
var paging = new PagingProperties(start, maxResults, getTotalCount);
var tags = queries.Find(t => new TagForApiContract(t, thumbPersister, ssl, fields),
queryParams, paging,
allowAliases, categoryName);
return(tags);
}
public static IQueryable <Tag> AddTagNameFilter(IQueryable <Tag> query, TagSearchTextQuery textQuery)
{
if (textQuery.IsEmpty)
{
return(query);
}
var name = textQuery.Query;
switch (textQuery.MatchMode)
{
case NameMatchMode.Exact:
return(query.Where(m => m.Name == name));
case NameMatchMode.StartsWith:
return(query.Where(m => m.Name.StartsWith(name)));
default:
return(query.Where(m => m.Name.Contains(name)));
}
}
public TagContract GetTagByName(string name)
{
var tag = tagQueries.Find(t => new TagContract(t, ContentLanguagePreference.Default, true), new TagQueryParams(new CommonSearchParams(TagSearchTextQuery.Create(name), false, true),
new PagingProperties(0, 1, false))).Items.FirstOrDefault();
return(tag);
}
public string[] FindTags(string term, int maxResults)
{
return(tagQueries.FindNames(TagSearchTextQuery.Create(term), true, 10));
}
public string[] GetNames(
string query = "", bool allowAliases = true,
int maxResults = 10)
{
return(queries.FindNames(TagSearchTextQuery.Create(query), allowAliases, true, maxResults));
}
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 Tag GetTagByName(IDatabaseContext <Tag> ctx, string name)
{
return(ctx.Query().WhereHasName(TagSearchTextQuery.Create(name, NameMatchMode.Exact)).FirstOrDefault());
}
public static IQueryable <Tag> AddTagNameFilter(this IQueryable <Tag> query, TagSearchTextQuery textQuery)
{
return(WhereHasName(query, textQuery));
}
public static IQueryable <Tag> WhereHasName(this IQueryable <Tag> query, TagSearchTextQuery textQuery)
{
return(FindHelpers.AddTagNameFilter(query, textQuery));
}
