public IQueryable <Album> Query(IDatabaseContext session)
{
var q = session.Query <AlbumName>();
return(FindHelpers.AddEntryNameFilter(q, new SearchTextQuery(string.Empty, NameMatchMode.Words, string.Empty, names))
.Select(n => n.Album));
}
public IQueryable <Album> Query(IQuerySource session)
{
var q = session.Query <AlbumName>();
return(FindHelpers.AddEntryNameFilter(q, string.Empty, NameMatchMode.Words, names)
.Select(n => n.Album));
}
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));
}
}
/*public void FilterResults(List<Album> albums, ISession session) {
*
* albums.RemoveAll(a => !(
* a.Names.Any(n => names.All(n2 => n.Value.IndexOf(n2, StringComparison.InvariantCultureIgnoreCase) != -1))));
*
* }
*
* public List<Album> GetResults(ISession session) {
*
* var q = session.Query<AlbumName>();
*
* foreach (var n2 in names)
* q = q.Where(n => n.Value.Contains(n2));
*
* return q.Select(n => n.Album).ToList();
*
* }*/
public IQueryable <Album> Filter(IQueryable <Album> query, IDatabaseContext session)
{
return(query.SelectMany(a => FindHelpers.AddEntryNameFilter(a.Names.Names.AsQueryable(), new SearchTextQuery(string.Empty, NameMatchMode.Words, string.Empty, names))).Select(n => n.Album));
}
/*public void FilterResults(List<Album> albums, ISession session) {
*
* albums.RemoveAll(a => !(
* a.Names.Any(n => names.All(n2 => n.Value.IndexOf(n2, StringComparison.InvariantCultureIgnoreCase) != -1))));
*
* }
*
* public List<Album> GetResults(ISession session) {
*
* var q = session.Query<AlbumName>();
*
* foreach (var n2 in names)
* q = q.Where(n => n.Value.Contains(n2));
*
* return q.Select(n => n.Album).ToList();
*
* }*/
public IQueryable <Album> Filter(IQueryable <Album> query, IQuerySource session)
{
return(query.SelectMany(a => FindHelpers.AddEntryNameFilter(a.Names.Names.AsQueryable(), string.Empty, NameMatchMode.Words, names)).Select(n => n.Album));
}
public int GetSongCount(string query, SongType[] songTypes, bool onlyByName, bool draftsOnly, NameMatchMode nameMatchMode,
TimeSpan timeFilter, bool onlyWithPVs, SongQueryParams queryParams)
{
bool filterByType = songTypes.Any();
if (queryParams.ArtistId == 0 && string.IsNullOrWhiteSpace(query))
{
var q = Query <Song>()
.Where(s => !s.Deleted);
if (draftsOnly)
{
q = q.Where(a => a.Status == EntryStatus.Draft);
}
if (filterByType)
{
q = q.Where(s => songTypes.Contains(s.SongType));
}
q = AddTimeFilter(q, timeFilter);
q = AddPVFilter(q, onlyWithPVs);
return(q.Count());
}
else if (queryParams.ArtistId != 0)
{
int artistId = queryParams.ArtistId;
var q = Query <ArtistForSong>()
.Where(m => !m.Song.Deleted && m.Artist.Id == artistId);
if (draftsOnly)
{
q = q.Where(a => a.Song.Status == EntryStatus.Draft);
}
if (filterByType)
{
q = q.Where(s => songTypes.Contains(s.Song.SongType));
}
q = AddTimeFilter(q, timeFilter);
q = AddPVFilter(q, onlyWithPVs);
return(q.Count());
}
else
{
var directQ = Query <Song>()
.Where(s => !s.Deleted);
if (draftsOnly)
{
directQ = directQ.Where(a => a.Status == EntryStatus.Draft);
}
if (filterByType)
{
directQ = directQ.Where(s => songTypes.Contains(s.SongType));
}
directQ = AddTimeFilter(directQ, timeFilter);
directQ = AddPVFilter(directQ, onlyWithPVs);
directQ = AddNameFilter(directQ, query, nameMatchMode, onlyByName);
var direct = directQ.ToArray();
var additionalNamesQ = Query <SongName>()
.Where(m => !m.Song.Deleted);
if (draftsOnly)
{
additionalNamesQ = additionalNamesQ.Where(a => a.Song.Status == EntryStatus.Draft);
}
if (filterByType)
{
additionalNamesQ = additionalNamesQ.Where(s => songTypes.Contains(s.Song.SongType));
}
additionalNamesQ = AddTimeFilter(additionalNamesQ, timeFilter);
additionalNamesQ = AddPVFilter(additionalNamesQ, onlyWithPVs);
additionalNamesQ = FindHelpers.AddEntryNameFilter(additionalNamesQ, query, nameMatchMode);
var additionalNames = additionalNamesQ
.Select(m => m.Song)
.Distinct()
.ToArray()
.Where(a => !direct.Contains(a))
.ToArray();
return(direct.Count() + additionalNames.Count());
}
}
/// <summary>
/// Finds songs based on criteria.
/// </summary>
/// <param name="queryParams">Query parameters. Cannot be null.</param>
/// <returns>List song search results. Cannot be null.</returns>
public PartialFindResult <Song> Find(SongQueryParams queryParams)
{
ParamIs.NotNull(() => queryParams);
var draftsOnly = queryParams.Common.DraftOnly;
var getTotalCount = queryParams.Paging.GetTotalCount;
var ignoreIds = queryParams.IgnoredIds;
var moveExactToTop = queryParams.Common.MoveExactToTop;
var nameMatchMode = queryParams.Common.NameMatchMode;
var onlyByName = queryParams.Common.OnlyByName;
var query = queryParams.Common.Query;
var songTypes = queryParams.SongTypes;
var sortRule = queryParams.SortRule;
var start = queryParams.Paging.Start;
var maxResults = queryParams.Paging.MaxEntries;
bool filterByType = songTypes.Any();
Song[] songs;
bool foundExactMatch = false;
if (queryParams.ArtistId == 0 && string.IsNullOrWhiteSpace(query))
{
var q = Query <Song>()
.Where(s => !s.Deleted &&
!ignoreIds.Contains(s.Id));
if (draftsOnly)
{
q = q.Where(a => a.Status == EntryStatus.Draft);
}
if (filterByType)
{
q = q.Where(s => songTypes.Contains(s.SongType));
}
q = AddTimeFilter(q, queryParams.TimeFilter);
q = AddPVFilter(q, queryParams.OnlyWithPVs);
q = q.AddOrder(sortRule, LanguagePreference);
songs = q
.Skip(start)
.Take(maxResults)
.ToArray();
}
else if (queryParams.ArtistId != 0)
{
int artistId = queryParams.ArtistId;
var q = Query <ArtistForSong>()
.Where(m => !m.Song.Deleted && m.Artist.Id == artistId);
if (draftsOnly)
{
q = q.Where(a => a.Song.Status == EntryStatus.Draft);
}
if (filterByType)
{
q = q.Where(s => songTypes.Contains(s.Song.SongType));
}
q = AddTimeFilter(q, queryParams.TimeFilter);
q = AddPVFilter(q, queryParams.OnlyWithPVs);
songs = q
.Select(m => m.Song)
.AddOrder(sortRule, LanguagePreference)
.Skip(start)
.Take(maxResults)
.ToArray();
}
else
{
query = query.Trim();
// Searching by SortNames can be disabled in the future because all names should be included in the Names list anyway.
var directQ = Query <Song>()
.Where(s => !s.Deleted);
if (draftsOnly)
{
directQ = directQ.Where(a => a.Status == EntryStatus.Draft);
}
if (filterByType)
{
directQ = directQ.Where(s => songTypes.Contains(s.SongType));
}
directQ = AddTimeFilter(directQ, queryParams.TimeFilter);
directQ = AddPVFilter(directQ, queryParams.OnlyWithPVs);
directQ = AddNameFilter(directQ, query, nameMatchMode, onlyByName);
directQ = directQ.AddOrder(sortRule, LanguagePreference);
var direct = directQ.ToArray();
var additionalNamesQ = Query <SongName>()
.Where(m => !m.Song.Deleted);
if (draftsOnly)
{
additionalNamesQ = additionalNamesQ.Where(a => a.Song.Status == EntryStatus.Draft);
}
additionalNamesQ = AddTimeFilter(additionalNamesQ, queryParams.TimeFilter);
additionalNamesQ = AddPVFilter(additionalNamesQ, queryParams.OnlyWithPVs);
additionalNamesQ = FindHelpers.AddEntryNameFilter(additionalNamesQ, query, nameMatchMode);
if (filterByType)
{
additionalNamesQ = additionalNamesQ.Where(m => songTypes.Contains(m.Song.SongType));
}
var additionalNames = additionalNamesQ
.Select(m => m.Song)
.AddOrder(sortRule, LanguagePreference)
.Distinct()
.ToArray()
.Where(a => !direct.Contains(a));
var entries = direct.Concat(additionalNames)
.Where(e => !ignoreIds.Contains(e.Id))
.Skip(start)
.Take(maxResults)
.ToArray();
if (moveExactToTop)
{
var exactMatch = entries
.Where(e => e.Names.Any(n => n.Value.StartsWith(query, StringComparison.InvariantCultureIgnoreCase)))
.ToArray();
if (exactMatch.Any())
{
entries = CollectionHelper.MoveToTop(entries, exactMatch).ToArray();
foundExactMatch = true;
}
}
songs = entries;
}
int count = (getTotalCount
? GetSongCount(query, songTypes, onlyByName, draftsOnly, nameMatchMode, queryParams.TimeFilter, queryParams.OnlyWithPVs, queryParams)
: 0);
return(new PartialFindResult <Song>(songs, count, queryParams.Common.Query, foundExactMatch));
}
public static IQueryable <T> WhereEntryNameIs <T>(this IQueryable <T> query, SearchTextQuery textQuery)
where T : LocalizedString
{
return(FindHelpers.AddEntryNameFilter(query, textQuery));
}