private void BuildItemList()
{
this.GroupedItemsList.Clear();
List <GroupItemList> groupedItems = GetItemsGrouped();
//Add Categories to the grouped list that do not contain any items
foreach (Category category in Categories)
{
List <Item> items = groupedItems.SingleOrDefault(list => list.Key == category.Name);
if (items == null)
{
GroupItemList group = new GroupItemList(new List <Item>())
{
Key = category.Name
};
groupedItems.Add(group);
}
}
groupedItems.Sort((g1, g2) => string.Compare(g1.Key, g2.Key));
groupedItems.ForEach(g => GroupedItemsList.Add(g));
}
async Task InsertIntoGroupArtist(ArtistItem artist)
{
try
{
var supposedFirstChar = Strings.HumanizedArtistFirstLetter(artist.Name);
var firstChar = GroupedArtists.FirstOrDefault(x => (string)x.Key == supposedFirstChar);
if (firstChar == null)
{
var newChar = new GroupItemList <ArtistItem>(artist)
{
Key = supposedFirstChar
};
if (GroupedArtists == null)
{
return;
}
int i = GroupedArtists.IndexOf(GroupedArtists.LastOrDefault(x => string.Compare((string)x.Key, (string)newChar.Key) < 0));
i++;
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => GroupedArtists.Insert(i, newChar));
}
else
{
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => firstChar.Add(artist));
}
}
catch { }
}
public async Task PopulateAlbumsWithTracks(ArtistItem artist)
{
try
{
var albums = musicDatabase.LoadAlbumsFromIdWithTracks(artist.Id).ToObservable();
var groupedAlbums = new ObservableCollection <GroupItemList <TrackItem> >();
var groupQuery = from album in albums
orderby album.Name
group album.Tracks by album into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <TrackItem> tracks = new GroupItemList <TrackItem>();
tracks.Key = g.GroupName;
foreach (var track in g.Items)
{
tracks.AddRange(track);
}
groupedAlbums.Add(tracks);
}
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () =>
{
artist.Albums = albums;
artist.AlbumsGrouped = groupedAlbums;
});
}
catch { }
}
async Task CreateFolderCategory(RootFolderType type)
{
var category = new GroupItemList <FileExplorer>()
{
Key = type
};
await DispatchHelper.InvokeAsync(CoreDispatcherPriority.Normal, () => FileExplorersGrouped.Add(category));
}
static async Task InsertIntoGroupAlbum(AlbumItem album)
{
if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByArtist)
{
var artist = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedArtistName(album.Artist));
if (artist == null)
{
artist = new GroupItemList <AlbumItem>(album)
{
Key = Strings.HumanizedArtistName(album.Artist)
};
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, artist.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, artist));
}
else
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => artist.Add(album));
}
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByDate)
{
var year = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedYear(album.Year));
if (year == null)
{
var newyear = new GroupItemList <AlbumItem>(album)
{
Key = Strings.HumanizedYear(album.Year)
};
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, newyear.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, newyear));
}
else
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => year.Add(album));
}
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByAlbum)
{
var firstChar = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedAlbumFirstLetter(album.Name));
if (firstChar == null)
{
var newChar = new GroupItemList <AlbumItem>(album)
{
Key = Strings.HumanizedAlbumFirstLetter(album.Name)
};
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, newChar.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, newChar));
}
else
{
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => firstChar.Add(album));
}
}
}
public ObservableCollection <GroupItemList <TrackItem> > OrderTracks()
{
var groupedTracks = new ObservableCollection <GroupItemList <TrackItem> >();
var groupQuery = from track in Tracks
group track by Strings.HumanizedArtistFirstLetter(track.Name) into a
orderby a.Key
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <TrackItem> tracks = new GroupItemList <TrackItem>();
tracks.Key = g.GroupName;
foreach (var artist in g.Items)
{
tracks.Add(artist);
}
groupedTracks.Add(tracks);
}
return(groupedTracks);
}
public ObservableCollection <GroupItemList <ArtistItem> > OrderArtists()
{
var groupedArtists = new ObservableCollection <GroupItemList <ArtistItem> >();
var groupQuery = from artist in Artists
group artist by Strings.HumanizedArtistFirstLetter(artist.Name) into a
orderby a.Key
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <ArtistItem> artists = new GroupItemList <ArtistItem>();
artists.Key = g.GroupName;
foreach (var artist in g.Items)
{
artists.Add(artist);
}
groupedArtists.Add(artists);
}
return(groupedArtists);
}
static async Task InsertIntoGroupAlbum(AlbumItem album)
{
if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByArtist)
{
var artist = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedArtistName(album.Artist));
if (artist == null)
{
artist = new GroupItemList<AlbumItem>(album) { Key = Strings.HumanizedArtistName(album.Artist) };
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, artist.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, artist));
}
else await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => artist.Add(album));
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByDate)
{
var year = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedYear(album.Year));
if (year == null)
{
var newyear = new GroupItemList<AlbumItem>(album) { Key = Strings.HumanizedYear(album.Year) };
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, newyear.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, newyear));
}
else await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => year.Add(album));
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByAlbum)
{
var firstChar = Locator.MusicLibraryVM.GroupedAlbums.FirstOrDefault(x => x.Key == Strings.HumanizedAlbumFirstLetter(album.Name));
if (firstChar == null)
{
var newChar = new GroupItemList<AlbumItem>(album) { Key = Strings.HumanizedAlbumFirstLetter(album.Name) };
int i = Locator.MusicLibraryVM.GroupedAlbums.IndexOf(Locator.MusicLibraryVM.GroupedAlbums.LastOrDefault(x => string.Compare(x.Key, newChar.Key) < 0));
i++;
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.MusicLibraryVM.GroupedAlbums.Insert(i, newChar));
}
else await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => firstChar.Add(album));
}
}
public static void OrderAlbums()
{
Task.Run(async () =>
{
var groupedAlbums = new ObservableCollection<GroupItemList<AlbumItem>>();
if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByArtist)
{
if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Ascending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Artist
group album by Strings.HumanizedArtistName(album.Artist) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList<AlbumItem> albums = new GroupItemList<AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
else if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Descending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Artist descending
group album by Strings.HumanizedArtistName(album.Artist) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList<AlbumItem> albums = new GroupItemList<AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByDate)
{
if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Ascending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Year
group album by Strings.HumanizedYear(album.Year) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList<AlbumItem> albums = new GroupItemList<AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
else if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Descending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Year descending
group album by Strings.HumanizedYear(album.Year) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList<AlbumItem> albums = new GroupItemList<AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByAlbum)
{
if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Ascending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Name
group album by Strings.HumanizedAlbumFirstLetter(album.Name) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList<AlbumItem> albums = new GroupItemList<AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
else if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Descending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Name descending
group album by Strings.HumanizedAlbumFirstLetter(album.Name) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList<AlbumItem> albums = new GroupItemList<AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
}
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => Locator.MusicLibraryVM.GroupedAlbums = groupedAlbums);
});
}
public static void OrderAlbums()
{
Task.Run(async() =>
{
var groupedAlbums = new ObservableCollection <GroupItemList <AlbumItem> >();
if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByArtist)
{
if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Ascending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Artist
group album by Strings.HumanizedArtistName(album.Artist) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <AlbumItem> albums = new GroupItemList <AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
else if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Descending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Artist descending
group album by Strings.HumanizedArtistName(album.Artist) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <AlbumItem> albums = new GroupItemList <AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByDate)
{
if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Ascending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Year
group album by Strings.HumanizedYear(album.Year) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <AlbumItem> albums = new GroupItemList <AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
else if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Descending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Year descending
group album by Strings.HumanizedYear(album.Year) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <AlbumItem> albums = new GroupItemList <AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
}
else if (Locator.SettingsVM.AlbumsOrderType == OrderType.ByAlbum)
{
if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Ascending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Name
group album by Strings.HumanizedAlbumFirstLetter(album.Name) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <AlbumItem> albums = new GroupItemList <AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
else if (Locator.SettingsVM.AlbumsOrderListing == OrderListing.Descending)
{
var groupQuery = from album in Locator.MusicLibraryVM.Albums
orderby album.Name descending
group album by Strings.HumanizedAlbumFirstLetter(album.Name) into a
select new { GroupName = a.Key, Items = a };
foreach (var g in groupQuery)
{
GroupItemList <AlbumItem> albums = new GroupItemList <AlbumItem>();
albums.Key = g.GroupName;
foreach (var album in g.Items)
{
albums.Add(album);
}
groupedAlbums.Add(albums);
}
}
}
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => Locator.MusicLibraryVM.GroupedAlbums = groupedAlbums);
});
}
