/// <summary>
/// Gets a filtered list of tracks.
/// </summary>
/// <param name="genreFilter">The genre filter.</param>
/// <param name="artistFilter">The artist filter.</param>
/// <param name="albumArtistFilter">The album artist filter.</param>
/// <param name="albumFilter">The album filter.</param>
/// <param name="searchFilter">The search filter.</param>
/// <param name="playlistFilter">The play-list filter.</param>
/// <param name="shufflerFilter">The shuffler filter.</param>
/// <param name="minBpm">The minimum BPM.</param>
/// <param name="maxBpm">The maximum BPM.</param>
/// <param name="trackRankFilter">The track rank filter.</param>
/// <param name="excludePlaylistFilter">The exclude play-list filter.</param>
/// <returns>
/// A list tracks matching the criteria.
/// </returns>
public List<Track> GetTracks(string genreFilter = "",
string artistFilter = "",
string albumArtistFilter = "",
string albumFilter = "",
string searchFilter = "",
string playlistFilter = "",
ShufflerFilter shufflerFilter = ShufflerFilter.None,
int minBpm = 0,
int maxBpm = 200,
TrackRankFilter trackRankFilter = TrackRankFilter.None,
string excludePlaylistFilter = "")
{
genreFilter = genreFilter.Replace(AllFilter, "").ToLower().Trim();
albumFilter = albumFilter.Replace(AllFilter, "").ToLower().Trim();
artistFilter = artistFilter.Replace(AllFilter, "").ToLower().Trim();
albumArtistFilter = albumArtistFilter.Replace(AllFilter, "").ToLower().Trim();
if (maxBpm == 0) maxBpm = 200;
List<Track> tracks;
lock (Tracks)
{
tracks = Tracks
.Where(t => genreFilter == "" || t.Genre.ToLower() == genreFilter)
.Where(t => albumFilter == "" || t.Album.ToLower() == albumFilter)
.Where(t => artistFilter == "" || t.Artist.ToLower() == artistFilter)
.Where(t => albumArtistFilter == "" || t.AlbumArtist.ToLower() == albumArtistFilter)
.Where(
t =>
(t.StartBpm >= minBpm && t.StartBpm <= maxBpm) || (t.EndBpm >= minBpm && t.EndBpm <= maxBpm))
.Distinct()
.OrderBy(t => t.AlbumArtist)
.ThenBy(t => t.Album)
.ThenBy(t => t.TrackNumber)
.ThenBy(t => t.Artist)
.ThenBy(t => t.Title)
.ToList();
}
if (!string.IsNullOrEmpty(searchFilter))
{
tracks = tracks.Where(t => t.Genre.ToLower().Contains(searchFilter)
|| t.AlbumArtist.ToLower().Contains(searchFilter)
|| t.Artist.ToLower().Contains(searchFilter)
|| t.Album.ToLower().Contains(searchFilter)
|| t.Title.ToLower().Contains(searchFilter)).ToList();
}
if (!string.IsNullOrEmpty(playlistFilter))
{
var playlist = GetPlaylistByName(playlistFilter);
if (playlist != null)
{
var playlistTracks = new HashSet<string>(playlist.Tracks.Select(t => t.Description).Distinct());
tracks = tracks.Where(t => playlistTracks.Contains(t.Description)).ToList();
}
}
if (!string.IsNullOrEmpty(excludePlaylistFilter))
{
var excludePlaylist = GetPlaylistByName(excludePlaylistFilter);
if (excludePlaylist != null)
{
var excludeTracks = new HashSet<string>(excludePlaylist.Tracks.Select(t => t.Description).Distinct());
tracks = tracks.Where(t => !excludeTracks.Contains(t.Description)).ToList();
}
}
switch (trackRankFilter)
{
case TrackRankFilter.Unranked:
tracks = tracks.Where(t => t.Rank == 1).ToList();
break;
case TrackRankFilter.Forbidden:
tracks = tracks.Where(t => t.Rank == 0).ToList();
break;
case TrackRankFilter.BearablePlus:
tracks = tracks.Where(t => t.Rank >= 2).ToList();
break;
case TrackRankFilter.GoodPlus:
tracks = tracks.Where(t => t.Rank >= 3).ToList();
break;
case TrackRankFilter.None:
break;
default:
throw new ArgumentOutOfRangeException(nameof(trackRankFilter), trackRankFilter, null);
}
if (shufflerFilter != ShufflerFilter.None)
{
tracks = shufflerFilter == ShufflerFilter.ShuflerTracks
? tracks.Where(t => t.IsShufflerTrack).ToList()
: tracks.Where(t => !t.IsShufflerTrack).ToList();
}
if (shufflerFilter != ShufflerFilter.ShuflerTracks)
return tracks;
//var distinctTracks = new List<Track>();
//foreach (
// var track in tracks.Where(track => distinctTracks.Count(t => t.Description == track.Description) == 0))
//{
// distinctTracks.Add(track);
//}
//tracks.Clear();
//tracks.AddRange(distinctTracks);
return tracks;
}
/// <summary>
/// Gets a filtered list of tracks.
/// </summary>
/// <param name="genreFilters">The genre filters.</param>
/// <param name="artistFilters">The artist filters.</param>
/// <param name="albumFilters">The album filters.</param>
/// <param name="searchFilter">The search filter.</param>
/// <param name="playlistFilter">The play-list filter.</param>
/// <param name="shufflerFilter">The shuffler filter.</param>
/// <param name="minBpm">The minimum BPM.</param>
/// <param name="maxBpm">The maximum BPM.</param>
/// <param name="trackRankFilter">The track rank filter.</param>
/// <param name="excludePlaylistFilter">The exclude play-list filter.</param>
/// <returns>
/// A list tracks matching the criteria.
/// </returns>
public List<Track> GetTracks(List<string> genreFilters,
List<string> artistFilters,
List<string> albumFilters,
string searchFilter,
string playlistFilter,
ShufflerFilter shufflerFilter,
int minBpm,
int maxBpm,
TrackRankFilter trackRankFilter,
string excludePlaylistFilter)
{
var tracks = new List<Track>();
if (genreFilters == null) genreFilters = new List<string>();
if (artistFilters == null) artistFilters = new List<string>();
if (albumFilters == null) albumFilters = new List<string>();
if (genreFilters.Contains("")) genreFilters.Clear();
if (artistFilters.Contains("")) artistFilters.Clear();
if (albumFilters.Contains("")) albumFilters.Clear();
if (genreFilters.Count == 0) genreFilters.Add("");
if (artistFilters.Count == 0) artistFilters.Add("");
if (albumFilters.Count == 0) albumFilters.Add("");
foreach (var genre in genreFilters)
{
foreach (var artist in artistFilters)
{
foreach (var album in albumFilters)
{
tracks.AddRange(
GetTracks(genre, "", artist, album, searchFilter, playlistFilter, shufflerFilter, minBpm,
maxBpm, trackRankFilter, excludePlaylistFilter)
.Union(GetTracks(genre, artist, "", album, searchFilter, playlistFilter, shufflerFilter,
minBpm, maxBpm, trackRankFilter, excludePlaylistFilter))
.Distinct()
.ToList());
}
}
}
tracks = tracks
.Distinct()
.OrderBy(t => t.AlbumArtist)
.ThenBy(t => t.Album)
.ThenBy(t => t.TrackNumber)
.ThenBy(t => t.Artist)
.ThenBy(t => t.Title)
.ToList();
if (shufflerFilter != ShufflerFilter.ShuflerTracks) return tracks;
var distinctTracks = new List<Track>();
foreach (
var track in tracks.Where(track => distinctTracks.Count(t => t.Description == track.Description) == 0))
{
distinctTracks.Add(track);
}
tracks.Clear();
tracks.AddRange(distinctTracks);
return tracks;
}
/// <summary>
/// Gets a filtered list of artists.
/// </summary>
/// <param name="genreFilter">The genre filter.</param>
/// <param name="searchFilter">The search filter.</param>
/// <param name="playlistFilter">The play-list filter.</param>
/// <param name="shufflerFilter">The shuffler filter.</param>
/// <param name="minBpm">The minimum BPM.</param>
/// <param name="maxBpm">The maximum BPM.</param>
/// <param name="trackRankFilter">The track rank filter.</param>
/// <param name="excludePlaylistFilter">The exclude play-list filter.</param>
/// <returns>
/// A list of artists matching the criteria.
/// </returns>
public List<Artist> GetArtists(string genreFilter,
string searchFilter,
string playlistFilter,
ShufflerFilter shufflerFilter,
int minBpm,
int maxBpm,
TrackRankFilter trackRankFilter,
string excludePlaylistFilter)
{
var artists =
GetTracks(genreFilter, "", "", "", searchFilter, playlistFilter, shufflerFilter, minBpm, maxBpm,
trackRankFilter, excludePlaylistFilter)
.OrderBy(t => t.AlbumArtist)
.Where(t => t.AlbumArtist != "")
.Select(t => t.AlbumArtist)
.Union(GetTracks(genreFilter, "", "", "", searchFilter, playlistFilter, shufflerFilter, minBpm,
maxBpm, trackRankFilter, excludePlaylistFilter)
.Where(t => t.Artist != "")
.OrderBy(t => t.Artist)
.Select(t => t.Artist))
.Distinct()
.Select(a => new Artist(a))
.ToList();
return artists;
}
/// <summary>
/// Gets a filtered list of album artists.
/// </summary>
/// <param name="genreFilters">The genre filters.</param>
/// <param name="searchFilter">The search filter.</param>
/// <param name="playlistFilter">The play-list filter.</param>
/// <param name="shufflerFilter">The shuffler filter.</param>
/// <param name="minBpm">The minimum BPM.</param>
/// <param name="maxBpm">The maximum BPM.</param>
/// <param name="trackRankFilter">The track rank filter.</param>
/// <param name="excludePlaylistFilter">The exclude play-list filter.</param>
/// <returns>
/// A list of album artists matching the criteria.
/// </returns>
public List<Artist> GetAlbumArtists(List<string> genreFilters,
string searchFilter,
string playlistFilter,
ShufflerFilter shufflerFilter,
int minBpm,
int maxBpm,
TrackRankFilter trackRankFilter,
string excludePlaylistFilter)
{
if (genreFilters == null)
{
genreFilters = new List<string> {""};
}
var artists = new List<string>();
foreach (var genreFilter in genreFilters)
{
artists.AddRange(
GetTracks(genreFilter, "", "", "", searchFilter, playlistFilter, shufflerFilter, minBpm, maxBpm,
trackRankFilter, excludePlaylistFilter)
.OrderBy(t => t.AlbumArtist)
.Where(t => t.AlbumArtist != "")
.Select(t => t.AlbumArtist)
.Distinct()
.ToList());
}
return artists
.Distinct()
.OrderBy(a => a)
.Where(a => a != "(All)")
.Select(a => new Artist(a))
.ToList();
}
/// <summary>
/// Gets a list of albums.
/// </summary>
/// <param name="genreFilters">The genre filters.</param>
/// <param name="albumArtistFilters">The album artist filters.</param>
/// <param name="searchFilter">The search filter.</param>
/// <param name="playlistFilter">The play-list filter.</param>
/// <param name="shufflerFilter">The shuffler filter.</param>
/// <param name="minBpm">The minimum BPM.</param>
/// <param name="maxBpm">The maximum BPM.</param>
/// <param name="trackRankFilter">The track rank filter.</param>
/// <param name="excludePlaylistFilter">The exclude play-list filter.</param>
/// <returns>
/// A list of albums matching the criteria.
/// </returns>
public List<Album> GetAlbums(List<string> genreFilters,
List<string> albumArtistFilters,
string searchFilter,
string playlistFilter,
ShufflerFilter shufflerFilter,
int minBpm,
int maxBpm,
TrackRankFilter trackRankFilter,
string excludePlaylistFilter)
{
if (genreFilters == null)
{
genreFilters = new List<string> {""};
}
if (albumArtistFilters == null)
{
albumArtistFilters = new List<string> {""};
}
var albums = new List<string>();
foreach (var genre in genreFilters)
{
foreach (var albumArtist in albumArtistFilters)
{
albums.AddRange(
GetTracks(genre, "", albumArtist, "", searchFilter, playlistFilter, shufflerFilter, minBpm,
maxBpm, trackRankFilter, excludePlaylistFilter)
.Union(GetTracks(genre, albumArtist, "", "", searchFilter, playlistFilter, shufflerFilter,
minBpm, maxBpm, trackRankFilter, excludePlaylistFilter))
.OrderBy(t => t.Album)
.Where(t => t.Album != "")
.Select(t => t.Album)
.Distinct()
.ToList());
}
}
return albums
.Distinct()
.OrderBy(a => a)
.Select(a => new Album(a))
.ToList();
}
/// <summary>
/// Gets a list of genres.
/// </summary>
/// <param name="searchFilter">The search filter.</param>
/// <param name="playlistFilter">The play-list filter.</param>
/// <param name="shufflerFilter">The shuffler filter.</param>
/// <param name="minBpm">The min BPM.</param>
/// <param name="maxBpm">The max BPM.</param>
/// <param name="trackRankFilter">The track rank filter.</param>
/// <param name="excludePlaylistFilter">The exclude play-list filter.</param>
/// <returns>
/// A list of genres.
/// </returns>
public List<Genre> GetGenres(string searchFilter,
string playlistFilter,
ShufflerFilter shufflerFilter,
int minBpm,
int maxBpm,
TrackRankFilter trackRankFilter,
string excludePlaylistFilter)
{
return
GetTracks("", "", "", "", searchFilter, playlistFilter, shufflerFilter, minBpm, maxBpm, trackRankFilter,
excludePlaylistFilter)
.OrderBy(t => t.Genre)
.Where(t => t.Genre != "" && t.Genre != "(All)")
.Select(t => t.Genre)
.Distinct()
.Select(g => new Genre(g))
.ToList();
}
