protected virtual void ToggleAlbumOrder()
{
switch (this.AlbumOrder)
{
case AlbumOrder.Alphabetical:
this.AlbumOrder = AlbumOrder.ByDateAdded;
break;
case AlbumOrder.ByDateAdded:
this.AlbumOrder = AlbumOrder.ByDateCreated;
break;
case AlbumOrder.ByDateCreated:
this.AlbumOrder = AlbumOrder.ByAlbumArtist;
break;
case AlbumOrder.ByAlbumArtist:
this.AlbumOrder = AlbumOrder.ByYear;
break;
case AlbumOrder.ByYear:
this.AlbumOrder = AlbumOrder.Alphabetical;
break;
default:
// Cannot happen, but just in case.
this.AlbumOrder = AlbumOrder.Alphabetical;
break;
}
}
protected void UpdateAlbumOrderText(AlbumOrder albumOrder)
{
switch (albumOrder)
{
case AlbumOrder.Alphabetical:
this.albumOrderText = ResourceUtils.GetString("Language_A_Z");
break;
case AlbumOrder.ByDateAdded:
this.albumOrderText = ResourceUtils.GetString("Language_By_Date_Added");
break;
case AlbumOrder.ByDateCreated:
this.albumOrderText = ResourceUtils.GetString("Language_By_Date_Created");
break;
case AlbumOrder.ByAlbumArtist:
this.albumOrderText = ResourceUtils.GetString("Language_By_Album_Artist");
break;
case AlbumOrder.ByYear:
this.albumOrderText = ResourceUtils.GetString("Language_By_Year");
break;
default:
// Cannot happen, but just in case.
this.albumOrderText = ResourceUtils.GetString("Language_A_Z");
break;
}
RaisePropertyChanged(nameof(this.AlbumOrderText));
}
protected async Task GetGenreAlbumsAsync(IList <string> selectedGenres, AlbumOrder albumOrder)
{
if (!selectedGenres.IsNullOrEmpty())
{
await this.GetAlbumsCommonAsync(await this.collectionService.GetGenreAlbumsAsync(selectedGenres), albumOrder);
return;
}
await this.GetAlbumsCommonAsync(await this.collectionService.GetAllAlbumsAsync(), albumOrder);
}
protected async Task GetAlbumsCommonAsync(IList <AlbumViewModel> albums, AlbumOrder albumOrder)
{
try
{
// Order the incoming Albums
IList <AlbumViewModel> orderedAlbums = await this.collectionService.OrderAlbumsAsync(albums, albumOrder);
// Create new ObservableCollection
var albumViewModels = new ObservableCollection <AlbumViewModel>(orderedAlbums);
// Unbind to improve UI performance
Application.Current.Dispatcher.Invoke(() =>
{
if (this.AlbumsCvs != null)
{
this.AlbumsCvs.Filter -= new FilterEventHandler(AlbumsCvs_Filter);
}
this.AlbumsCvs = null;
});
this.Albums = null;
// Populate ObservableCollection
this.Albums = albumViewModels;
}
catch (Exception ex)
{
LogClient.Error("An error occurred while getting Albums. Exception: {0}", ex.Message);
// Failed getting Albums. Create empty ObservableCollection.
Application.Current.Dispatcher.Invoke(() =>
{
this.Albums = new ObservableCollection <AlbumViewModel>();
});
}
Application.Current.Dispatcher.Invoke(() =>
{
// Populate CollectionViewSource
this.AlbumsCvs = new CollectionViewSource {
Source = this.Albums
};
this.AlbumsCvs.Filter += new FilterEventHandler(AlbumsCvs_Filter);
// Update count
this.AlbumsCount = this.AlbumsCvs.View.Cast <AlbumViewModel>().Count();
});
// Set Album artwork
this.LoadAlbumArtworkAsync(Constants.ArtworkLoadDelay);
}
public async Task <IList <AlbumViewModel> > OrderAlbumsAsync(IList <AlbumViewModel> albums, AlbumOrder albumOrder)
{
var orderedAlbums = new List <AlbumViewModel>();
await Task.Run(() =>
{
switch (albumOrder)
{
case AlbumOrder.Alphabetical:
orderedAlbums = albums.OrderBy((a) => FormatUtils.GetSortableString(a.AlbumTitle)).ToList();
break;
case AlbumOrder.ByDateAdded:
orderedAlbums = albums.OrderByDescending((a) => a.DateAdded).ToList();
break;
case AlbumOrder.ByDateCreated:
orderedAlbums = albums.OrderByDescending((a) => a.DateFileCreated).ToList();
break;
case AlbumOrder.ByAlbumArtist:
orderedAlbums = albums.OrderBy((a) => FormatUtils.GetSortableString(a.AlbumArtist, true)).ToList();
break;
case AlbumOrder.ByYear:
orderedAlbums = albums.OrderByDescending((a) => a.SortYear).ToList();
break;
default:
// Alphabetical
orderedAlbums = albums.OrderBy((a) => FormatUtils.GetSortableString(a.AlbumTitle)).ToList();
break;
}
foreach (AlbumViewModel alb in orderedAlbums)
{
string mainHeader = alb.AlbumTitle;
string subHeader = alb.AlbumArtist;
switch (albumOrder)
{
case AlbumOrder.ByAlbumArtist:
mainHeader = alb.AlbumArtist;
subHeader = alb.AlbumTitle;
break;
case AlbumOrder.ByYear:
mainHeader = alb.Year;
subHeader = alb.AlbumTitle;
break;
case AlbumOrder.Alphabetical:
case AlbumOrder.ByDateAdded:
case AlbumOrder.ByDateCreated:
default:
// Do nothing
break;
}
alb.MainHeader = mainHeader;
alb.SubHeader = subHeader;
}
});
return(orderedAlbums);
}
protected async Task GetAlbumsCommonAsync(IList <Album> albums, AlbumOrder albumOrder)
{
try
{
// Create new ObservableCollection
var albumViewModels = new ObservableCollection <AlbumViewModel>();
// Order the incoming Albums
List <Album> orderedAlbums = await DataUtils.OrderAlbumsAsync(albums, albumOrder);
await Task.Run(() =>
{
foreach (Album alb in orderedAlbums)
{
string mainHeader = alb.AlbumTitle;
string subHeader = alb.AlbumArtist;
switch (albumOrder)
{
case AlbumOrder.ByAlbumArtist:
mainHeader = alb.AlbumArtist;
subHeader = alb.AlbumTitle;
break;
case AlbumOrder.ByYear:
mainHeader = alb.Year.HasValue && alb.Year.Value > 0 ? alb.Year.ToString() : string.Empty;
subHeader = alb.AlbumTitle;
break;
case AlbumOrder.Alphabetical:
case AlbumOrder.ByDateAdded:
case AlbumOrder.ByDateCreated:
default:
// Do nothing
break;
}
albumViewModels.Add(new AlbumViewModel
{
Album = alb,
MainHeader = mainHeader,
SubHeader = subHeader
});
}
});
// Unbind to improve UI performance
if (this.AlbumsCvs != null)
{
this.AlbumsCvs.Filter -= new FilterEventHandler(AlbumsCvs_Filter);
}
this.Albums = null;
this.AlbumsCvs = null;
// Populate ObservableCollection
this.Albums = albumViewModels;
}
catch (Exception ex)
{
LogClient.Error("An error occurred while getting Albums. Exception: {0}", ex.Message);
// Failed getting Albums. Create empty ObservableCollection.
this.Albums = new ObservableCollection <AlbumViewModel>();
}
// Populate CollectionViewSource
this.AlbumsCvs = new CollectionViewSource {
Source = this.Albums
};
this.AlbumsCvs.Filter += new FilterEventHandler(AlbumsCvs_Filter);
// Update count
this.AlbumsCount = this.AlbumsCvs.View.Cast <AlbumViewModel>().Count();
// Set Album artwork
this.SetAlbumArtworkAsync(Constants.ArtworkLoadDelay);
}
protected async Task GetAlbumsAsync(IList <Artist> selectedArtists, IList <long> selectedGenreIds, AlbumOrder albumOrder)
{
if (selectedArtists.IsNullOrEmpty() & selectedGenreIds.IsNullOrEmpty())
{
await this.GetAlbumsCommonAsync(await this.albumRepository.GetAlbumsAsync(), albumOrder);
}
else
{
if (!selectedArtists.IsNullOrEmpty())
{
await this.GetAlbumsCommonAsync(await this.albumRepository.GetArtistAlbumsAsync(selectedArtists), albumOrder);
return;
}
if (!selectedGenreIds.IsNullOrEmpty())
{
await this.GetAlbumsCommonAsync(await this.albumRepository.GetGenreAlbumsAsync(selectedGenreIds), albumOrder);
return;
}
}
}
public static async Task <List <Album> > OrderAlbumsAsync(IList <Album> albums, AlbumOrder albumOrder)
{
var orderedAlbums = new List <Album>();
await Task.Run(() =>
{
switch (albumOrder)
{
case AlbumOrder.Alphabetical:
orderedAlbums = albums.OrderBy((a) => GetSortableString(a.AlbumTitle)).ToList();
break;
case AlbumOrder.ByDateAdded:
orderedAlbums = albums.OrderByDescending((a) => a.DateAdded).ToList();
break;
case AlbumOrder.ByAlbumArtist:
orderedAlbums = albums.OrderBy((a) => GetSortableString(a.AlbumArtist, true)).ToList();
break;
case AlbumOrder.ByYear:
orderedAlbums = albums.OrderByDescending((a) => a.Year != null ? a.Year : 0).ToList();
break;
default:
// Alphabetical
orderedAlbums = albums.OrderBy((a) => GetSortableString(a.AlbumTitle)).ToList();
break;
}
});
return(orderedAlbums);
}
protected async Task GetAllAlbumsAsync(AlbumOrder albumOrder)
{
await this.GetAlbumsCommonAsync(await this.collectionService.GetAllAlbumsAsync(), albumOrder);
}
protected async Task GetArtistAlbumsAsync(IList <string> selectedArtists, ArtistType artistType, AlbumOrder albumOrder)
{
if (!selectedArtists.IsNullOrEmpty())
{
await this.GetAlbumsCommonAsync(await this.collectionService.GetArtistAlbumsAsync(selectedArtists, artistType), albumOrder);
return;
}
await this.GetAlbumsCommonAsync(await this.collectionService.GetAllAlbumsAsync(), albumOrder);
}
