private async Task Init()
{
var albumsinlist = await _albumListAlbumService.Get <List <AlbumListAlbum> >(new AlbumListAlbumSearchRequest()
{
AlbumListId = AlbumListId
});
if (AddAlbums == false)
{
foreach (var item in albumsinlist)
{
var thisAlbum = await _albumService.GetById <Album>(item.AlbumId);
var thisArtist = await _artistService.GetById <Artist>(thisAlbum.ArtistId);
AlbumHelperVM local = new AlbumHelperVM()
{
AlbumId = thisAlbum.AlbumId,
AlbumName = thisAlbum.AlbumName,
ArtistId = thisArtist.ArtistId,
ArtistName = thisArtist.ArtistName,
AlbumGeneratedRating = "Rating: " + thisAlbum.AlbumGeneratedRating.ToString() + "/5",
AlbumPhoto = thisAlbum.AlbumPhoto, DateReleased = thisAlbum.DateReleased
};
Albums.Add(local);
AllAlbums.Add(local);
}
}
}
private async Task Init()
{
var returned = await _albumService.Get <List <Album> >(new AlbumSearchRequest()
{
ArtistId = ThisArtistId
});
foreach (var item in returned)
{
var thisArtist = await _artistService.GetById <Artist>(item.ArtistId);
AlbumHelperVM local = new AlbumHelperVM()
{
ArtistId = item.ArtistId,
AlbumGeneratedRating = "Rating: " + item.AlbumGeneratedRating + "/5",
AlbumId = item.AlbumId,
AlbumName = item.AlbumName,
AlbumPhoto = item.AlbumPhoto,
ArtistName = thisArtist.ArtistName,
DateReleased = item.DateReleased
};
Albums.Add(local);
AllAlbums.Add(local);
}
}
private async Task Clicked()
{
AlbumListAlbumUpsertRequest req = new AlbumListAlbumUpsertRequest()
{
AlbumId = SelectedAlbum.AlbumId,
AlbumListId = AlbumListId
};
try
{
if (AddAlbums == true)
{
await _albumListAlbumService.Insert <AlbumListAlbum>(req);
}
else
{
await _albumListAlbumService.Update <AlbumListAlbum>(0, req);
}
Albums.Remove(SelectedAlbum);
AllAlbums.Remove(SelectedAlbum);
SelectedAlbum = null;
}
catch (Exception ex)
{
await Application.Current.MainPage.DisplayAlert("Error", ex.Message, "OK");
}
}
public async Task SearchAlbums(IEnumerable <Music> source, string keyword, SortBy criterion)
{
AllAlbums.SetTo(await Task.Run(() => SearchHelper.SearchAlbums(source, keyword, criterion)));
Albums.SetTo(AllAlbums.Take(AlbumLimit));
AlbumsTextBlock.Text = Settings.settings.ShowCount ? Helper.LocalizeText("AlbumsWithCount", AllAlbums.Count) : Helper.LocalizeText("Albums");
AlbumsViewAllButton.Visibility = AllAlbums.Count > AlbumLimit ? Visibility.Visible : Visibility.Collapsed;
SortAlbumsButton.Visibility = Albums.Count < 2 ? Visibility.Collapsed : Visibility.Visible;
}
/// <summary>
/// Add album to user collection.
/// </summary>
/// <param name="album">Album to be added. Cannot be null.</param>
/// <param name="status">Purchase status.</param>
/// <param name="mediaType">Media type.</param>
/// <param name="rating">Rating.</param>
/// <returns>Album link. Cannot be null.</returns>
public virtual AlbumForUser AddAlbum(Album album, PurchaseStatus status, MediaType mediaType, int rating)
{
ParamIs.NotNull(() => album);
var link = new AlbumForUser(this, album, status, mediaType, rating);
AllAlbums.Add(link);
album.UserCollections.Add(link);
album.UpdateRatingTotals();
return(link);
}
private void SortAlbumsButton_Click(object sender, RoutedEventArgs e)
{
MenuFlyoutHelper.SetSortByMenu(sender, Settings.settings.SearchAlbumsCriterion, AlbumsCriteria,
async item =>
{
Settings.settings.SearchAlbumsCriterion = item;
LoadingProgress.Visibility = Visibility.Visible;
AllAlbums.SetTo(await Task.Run(() => SearchHelper.SortAlbums(AllAlbums, CurrentKeyword.Text, item).ToList()));
Albums.SetTo(AllAlbums.Take(Albums.Count));
LoadingProgress.Visibility = Visibility.Collapsed;
});
}
public object Get(AllAlbums request)
{
List <Album> result = new List <Album>();
using (TagsDBUser user = new TagsDBUser(request.Test))
{
foreach (Ares.Tags.Album album in user.TagsDB.BrowseInterface.GetAllAlbums())
{
result.Add(CreateItemResponse <Album, Ares.Tags.Album>(request, album, user));
}
return(CreateHttpResponse(request, CreateItemResponse <AllAlbumsResponse, List <Album> >(request, result, user)));
}
}
public async void DeleteAlbum(int albumId)
{
if (albumLookupDictionary.ContainsKey(albumId))
{
AlbumModel albumToRemove = albumLookupDictionary[albumId];
albumToRemove.DeleteArt();
AllAlbums.Remove(albumToRemove);
albumLookupDictionary.Remove(albumId);
}
DatabaseManager.Current.DeleteAlbum(albumId);
}
public void OnLoad()
{
List <AlbumsListModel> albums = albumRepository.GetAll();
AllAlbums.Clear();
foreach (var albumListModel in albums)
{
AllAlbums.Add(new AlbumsListModel()
{
Id = albumListModel.Id,
Name = albumListModel.Name
});
}
}
public virtual ArtistForAlbum AddAlbum(Album album, bool support, ArtistRoles roles)
{
ParamIs.NotNull(() => album);
// Check is too slow for now
//if (HasAlbum(album))
// throw new InvalidOperationException(string.Format("{0} has already been added for {1}", album, this));
var link = new ArtistForAlbum(album, this, support, roles);
AllAlbums.Add(link);
album.AllArtists.Add(link);
return(link);
}
private async Task LoadTracks()
{
var tracksReturned = await _trackService.Get <List <Model.Track> >(null);
foreach (var item in tracksReturned)
{
TrackHelperVM local = new TrackHelperVM()
{
TrackId = item.TrackId,
TrackName = item.TrackName,
AlbumName = AllAlbums.Where(a => a.AlbumId == item.AlbumId).Select(a => a.AlbumName).FirstOrDefault(),
AlbumId = item.AlbumId
};
local.ArtistId = AllAlbums.Where(a => a.AlbumId == local.AlbumId).Select(a => a.ArtistId).FirstOrDefault();
local.ArtistName = AllArtists.Where(a => a.ArtistId == local.ArtistId).Select(a => a.ArtistName).FirstOrDefault();
AllTracks.Add(local);
QueryTracks.Add(local);
}
}
private async Task LoadAlbums()
{
var allAlbums = await _albumService.Get <List <Model.Album> >(null);
foreach (var item in allAlbums)
{
AlbumHelperVM local = new AlbumHelperVM()
{
AlbumGeneratedRating = "Rating: " + item.AlbumGeneratedRating.ToString() + "/5",
AlbumId = item.AlbumId,
AlbumName = item.AlbumName,
AlbumPhoto = item.AlbumPhoto,
ArtistId = item.ArtistId,
DateReleased = "Released: " + item.DateReleased
};
local.ArtistName = AllArtists.Where(a => a.ArtistId == local.ArtistId).Select(a => a.ArtistName).FirstOrDefault();
AllAlbums.Add(local);
QueryAlbums.Add(local);
}
}
public virtual CollectionDiff <ArtistForAlbum, ArtistForAlbum> SyncAlbums(
IEnumerable <AlbumForArtistEditContract> newAlbums, Func <AlbumForArtistEditContract, Album> albumGetter)
{
var albumDiff = CollectionHelper.Diff(Albums, newAlbums, (a1, a2) => (a1.Id == a2.ArtistForAlbumId));
var created = new List <ArtistForAlbum>();
foreach (var removed in albumDiff.Removed)
{
removed.Delete();
AllAlbums.Remove(removed);
}
foreach (var added in albumDiff.Added)
{
var album = albumGetter(added);
var link = AddAlbum(album);
created.Add(link);
}
return(new CollectionDiff <ArtistForAlbum, ArtistForAlbum>(created, albumDiff.Removed, albumDiff.Unchanged));
}
private void Process(List <File> selection, List <File> allFiles)
{
string currAlbum = null;
string currArtist = null;
string currAA = null;
string currGenre = null;
string currComposer = null;
string currConductor = null;
string currGrouping = null;
string currCopyright = null;
bool set = false;
foreach (File f in allFiles)
{
if (f.Tags.Title != null && f.Tags.Title.Length > 0)
{
AllTitles.Add(f.Tags.Title);
}
string fname = Path.GetFileName(f.FileName);
Match match = Regex.Match(fname, @"(?:\d+\.?)?(?:[\s_]?-[\s_]?)?(.*?)\.[^\.]+$");
if (match.Success)
{
string val = match.Groups[1].Value;
val = val.Replace('_', ' ');
val = val.Replace('.', ' ');
val = Regex.Replace(val, @"\s+", " ");
val = val.Trim();
if (val.Length > 0)
{
AllTitles.Add(val);
}
if (f.Tags.Album != null && f.Tags.Album.Length > 0)
{
AllAlbums.Add(f.Tags.Album);
}
if (f.Tags.Artists != null && f.Tags.Artists.Length > 0)
{
AllArtists.Add(f.Tags.Artists);
}
if (f.Tags.AlbumArtists != null && f.Tags.AlbumArtists.Length > 0)
{
AllAlbumArtists.Add(f.Tags.AlbumArtists);
}
if (f.Tags.Genres != null && f.Tags.Genres.Length > 0)
{
AllGenres.Add(f.Tags.Genres);
}
if (f.Tags.Composers != null && f.Tags.Composers.Length > 0)
{
AllComposers.Add(f.Tags.Composers);
}
if (f.Tags.Conductor != null && f.Tags.Conductor.Length > 0)
{
AllConductors.Add(f.Tags.Conductor);
}
if (f.Tags.Grouping != null && f.Tags.Grouping.Length > 0)
{
AllGroupings.Add(f.Tags.Grouping);
}
if (f.Tags.Copyright != null && f.Tags.Copyright.Length > 0)
{
AllCopyrights.Add(f.Tags.Copyright);
}
}
}
foreach (File f in selection)
{
if (!set)
{
currAlbum = f.Tags.Album;
currArtist = f.Tags.Artists;
currAA = f.Tags.AlbumArtists;
currGenre = f.Tags.Genres;
currComposer = f.Tags.Composers;
currConductor = f.Tags.Conductor;
currGrouping = f.Tags.Grouping;
currCopyright = f.Tags.Copyright;
}
else
{
if (SameAlbum && currAlbum != f.Tags.Album)
{
SameAlbum = false;
}
else
{
currAlbum = f.Tags.Album;
}
if (SameArtists && currArtist != f.Tags.Artists)
{
SameArtists = false;
}
else
{
currArtist = f.Tags.Artists;
}
if (SameAlbumArtists && currAA != f.Tags.AlbumArtists)
{
SameAlbumArtists = false;
}
else
{
currAA = f.Tags.AlbumArtists;
}
if (SameGenres && currGenre != f.Tags.Genres)
{
SameGenres = false;
}
else
{
currGenre = f.Tags.Genres;
}
if (SameComposers && currComposer != f.Tags.Composers)
{
SameComposers = false;
}
else
{
currComposer = f.Tags.Composers;
}
if (SameConductor && currConductor != f.Tags.Conductor)
{
SameConductor = false;
}
else
{
currConductor = f.Tags.Conductor;
}
if (SameGrouping && currGrouping != f.Tags.Grouping)
{
SameGrouping = false;
}
else
{
currGrouping = f.Tags.Grouping;
}
if (SameCopyright && currCopyright != f.Tags.Copyright)
{
SameCopyright = false;
}
else
{
currCopyright = f.Tags.Copyright;
}
}
set = true;
}
SetValues(selection);
}
public Album GetAlbumById(int albumId)
{
return(AllAlbums.FirstOrDefault(p => p.AlbumId == albumId));
}
