private void ExecuteSearchForAlbum(string artist, string album)
{
Task.Factory.StartNew(state => GetAlbumMatchingName(state), Tuple.Create(artist, album))
.ContinueWith(task =>
{
var data = (Tuple <string, string>)task.AsyncState;
if (task.Exception != null)
{
ToastService.Show("Error occurred during fetching of album");
Logger.Log(task.Exception.ToString(), Category.Exception, Priority.Medium);
}
else
{
CurrentTrackContainer = task.Result;
if (task.Result == null)
{
ToastService.Show("Unable to find album " + data.Item2 + " by " + data.Item1);
}
else
{
Task childTask = new Task(state =>
{
var albumInfo = (Tuple <string, string>)task.AsyncState;
LookUpAlbumInformation(albumInfo.Item1, albumInfo.Item2);
}, data, TaskCreationOptions.AttachedToParent);
childTask.Start();
}
}
});
}
private void ExecuteGoToAlbum(TrackContainer album)
{
UriQuery q = new UriQuery();
q.Add("artistName", album.Owner.Name);
q.Add("albumName", album.Name);
RegionManager.RequestNavigate(AppRegions.ViewRegion, typeof(AlbumView).FullName + q);
}
public IEnumerable <TrackContainer> GetAlbumsByArtist(string artist)
{
List <TrackContainer> containers = new List <TrackContainer>();
if (!IsLoggedIn())
{
return(containers);
}
QueryServiceClient query = new QueryServiceClient();
try
{
var queryResult = query.Query(artist, 0, 0, 0, 0, 0, 10);
var result =
queryResult.Artists.FirstOrDefault(
a => a.Name.Equals(artist, StringComparison.InvariantCultureIgnoreCase));
if (result == null && queryResult.Artists.Any())
{
result = queryResult.Artists.FirstOrDefault();
}
if (result != null)
{
var browse = query.ArtistBrowse(result.ID, ArtistBrowsingType.Full);
var albumGroups = browse.Tracks.Where(t => t.IsAvailable).GroupBy(t => t.Album.ID);
foreach (var albumGroup in albumGroups)
{
TrackContainer container = new TrackContainer();
container.Owner = new TrackContainerOwner(artist);
container.Tracks = albumGroup.Select(SpotifyRadioTrackPlayer.ConvertTrack).ToArray();
var firstOrDefault = container.Tracks.FirstOrDefault();
if (firstOrDefault != null)
{
container.Name = firstOrDefault.Album;
container.Image = container.Image = firstOrDefault.AlbumArt;
}
containers.Add(container);
}
}
query.Close();
}
catch (Exception e)
{
_logger.Log(e.Message, Category.Exception, Priority.Medium);
query.Abort();
}
return(containers);
}
public async Task UploadCollectionAsync_WhenBlobNameIsEmpty_ShouldThrow()
{
// --- Arrange
TrackContainer trackContainer = GetMock.TrackContainer();
var resultJson = Serializer.WriteFromObject(typeof(TrackContainer), trackContainer);
var sut = new BlobStorageRepository(_blobConnectionString);
// --- Act
string blobName = "";
await sut.UploadCollectionAsync(resultJson, blobName);
}
public void GetBlobs_WhenBlobStorageHasItemsAndPrefixIsFound_ShouldReturnItems()
{
var sut = new BlobStorageRepository(_blobConnectionString);
TrackContainer trackContainer = GetMock.TrackContainer();
var resultJson = Serializer.WriteFromObject(typeof(TrackContainer), trackContainer);
var blobItem = sut.UploadCollection(resultJson, trackContainer.Id);
// --- Act
var blobItems = sut.GetBlobs(blobItem.BlobId);
// --- Assert
Assert.IsNotNull(blobItems);
Assert.IsTrue(blobItems.ToArray().Length > 0);
}
public async Task UploadCollectionAsync_WhenCollectionValidUploadToAzure_ShouldUpload()
{
// --- Arrange
TrackContainer trackContainer = GetMock.TrackContainer();
var resultJson = Serializer.WriteFromObject(typeof(TrackContainer), trackContainer);
var sut = new BlobStorageRepository(_blobConnectionString);
// --- Act
var blobName = trackContainer.Id;
var blobItem = await sut.UploadCollectionAsync(resultJson, blobName);
// --- Assert
Assert.IsNotNull(blobItem);
Assert.AreEqual(blobName, blobItem.BlobId);
Assert.IsTrue(blobItem.BlobUri.AbsoluteUri.LastIndexOf(blobName) > 0);
}
public void SerializeAndDeserializeObject_WhenObjectHasDataContractAttributes_ShouldGetTheObjectBack()
{
TrackContainer trackContainer = GetMock.TrackContainer();
var resultJson = Serializer.WriteFromObject(typeof(TrackContainer), trackContainer);
Assert.IsNotNull(resultJson);
var deserializedTrackContainer = Serializer.ReadToTrackObject <TrackContainer>(resultJson);
Assert.IsNotNull(deserializedTrackContainer);
Assert.AreEqual(trackContainer.Id, deserializedTrackContainer.Id);
Assert.AreEqual(trackContainer.LeftCornerPosition.X, deserializedTrackContainer.LeftCornerPosition.X);
Assert.AreEqual(trackContainer.LeftCornerPosition.Y, deserializedTrackContainer.LeftCornerPosition.Y);
Assert.AreEqual(trackContainer.LeftCornerPosition.Z, deserializedTrackContainer.LeftCornerPosition.Z);
Assert.AreEqual(trackContainer.Tracks.ElementAt(0).Id, deserializedTrackContainer.Tracks.ElementAt(0).Id);
Assert.AreEqual(trackContainer.Tracks.ElementAt(1).Id, deserializedTrackContainer.Tracks.ElementAt(1).Id);
}
public IEnumerable <TrackContainer> GetAlbumsByArtist(string artist)
{
List <TrackContainer> containers = new List <TrackContainer>();
try
{
var response = GroovesharkModule.GetClient().SearchArtist(artist);
var results = response.result.result as List <SearchArtist.SearchArtistResult>;
var byAlbum = results
.Where(s => artist.Equals(s.ArtistName, StringComparison.InvariantCultureIgnoreCase))
.GroupBy(s => new { Album = s.AlbumName, Year = s.Year });
foreach (var albumGroup in byAlbum)
{
int year;
if (!int.TryParse(albumGroup.Key.Year, out year))
{
year = DateTime.Now.Year;
}
TrackContainer container = new TrackContainer
{
Name = albumGroup.Key.Album,
Year = year,
Owner = new TrackContainerOwner(artist),
Tracks = Convert(albumGroup).OrderBy(t => t.Index).ToArray(),
};
var firstTrack = container.Tracks.FirstOrDefault();
if (firstTrack != null)
{
container.Image = firstTrack.AlbumArt;
}
containers.Add(container);
}
}
catch (Exception e)
{
_logger.Log("Grooveshark: " + e, Category.Exception, Priority.Medium);
}
return(containers);
}
public void DownloadBlob_WhenValidCollectionUploadedAzure_ShouldDownloadToCollectionObject()
{
// --- Arrange
TrackContainer trackContainer = GetMock.TrackContainer();
var containerJson = Serializer.WriteFromObject(typeof(TrackContainer), trackContainer);
var sut = new BlobStorageRepository(_blobConnectionString);
// --- Act
var blobName = trackContainer.Id;
sut.UploadCollection(containerJson, blobName);
var objectString = sut.DownloadBlob(blobName);
var container = Serializer.ReadToTrackObject <TrackContainer>(objectString);
// --- Assert
Assert.IsNotNull(container);
}
private void ExecuteAddTrackContainerToFavorites(object parameter)
{
IEnumerable <TrackContainer> containers;
TrackContainer container = parameter as TrackContainer;
if (container != null)
{
containers = new[] { container };
}
else
{
containers = parameter as IEnumerable <TrackContainer>;
}
if (containers != null && containers.Any())
{
try
{
using (var session = DocumentStore.OpenSession())
{
foreach (var trackContainer in containers)
{
TrackContainerFavorite fav = new TrackContainerFavorite();
fav.TrackContainer = trackContainer;
fav.Index = session.Query <Favorite>().Count();
session.Store(fav);
}
session.SaveChanges();
}
ToastService.Show(new ToastData
{
Icon = AppIcons.Save,
Message = "Favorite added"
});
}
catch (Exception e)
{
ToastService.Show("Unable to save favorite. " + e.Message);
Logger.Log("Error while saving favorite. " + e, Category.Exception, Priority.High);
}
}
}
public IEnumerable<TrackContainer> GetAlbumsByArtist(string artist)
{
List<TrackContainer> containers = new List<TrackContainer>();
try
{
var response = GroovesharkModule.GetClient().SearchArtist(artist);
var results = response.result.result as List<SearchArtist.SearchArtistResult>;
var byAlbum = results
.Where(s => artist.Equals(s.ArtistName, StringComparison.InvariantCultureIgnoreCase))
.GroupBy(s => new { Album = s.AlbumName, Year = s.Year });
foreach (var albumGroup in byAlbum)
{
int year;
if (!int.TryParse(albumGroup.Key.Year, out year))
{
year = DateTime.Now.Year;
}
TrackContainer container = new TrackContainer
{
Name = albumGroup.Key.Album,
Year = year,
Owner = new TrackContainerOwner(artist),
Tracks = Convert(albumGroup).OrderBy(t => t.Index).ToArray(),
};
var firstTrack = container.Tracks.FirstOrDefault();
if (firstTrack != null)
{
container.Image = firstTrack.AlbumArt;
}
containers.Add(container);
}
}
catch (Exception e)
{
_logger.Log("Grooveshark: " + e, Category.Exception, Priority.Medium);
}
return containers;
}
void INavigationAware.OnNavigatedFrom(NavigationContext navigationContext)
{
CurrentTrackContainer = null;
}
public IEnumerable<TrackContainer> GetAlbumsByArtist(string artist)
{
List<TrackContainer> containers = new List<TrackContainer>();
if (!IsLoggedIn())
{
return containers;
}
QueryServiceClient query = new QueryServiceClient();
try
{
var queryResult = query.Query(artist, 0, 0, 0, 0, 0, 10);
var result =
queryResult.Artists.FirstOrDefault(
a => a.Name.Equals(artist, StringComparison.InvariantCultureIgnoreCase));
if (result == null && queryResult.Artists.Any())
{
result = queryResult.Artists.FirstOrDefault();
}
if (result != null)
{
var browse = query.ArtistBrowse(result.ID, ArtistBrowsingType.Full);
var albumGroups = browse.Tracks.Where(t => t.IsAvailable).GroupBy(t => t.Album.ID);
foreach (var albumGroup in albumGroups)
{
TrackContainer container = new TrackContainer();
container.Owner = new TrackContainerOwner(artist);
container.Tracks = albumGroup.Select(SpotifyRadioTrackPlayer.ConvertTrack).ToArray();
var firstOrDefault = container.Tracks.FirstOrDefault();
if (firstOrDefault != null)
{
container.Name = firstOrDefault.Album;
container.Image = container.Image = firstOrDefault.AlbumArt;
}
containers.Add(container);
}
}
query.Close();
}
catch (Exception e)
{
_logger.Log(e.Message, Category.Exception, Priority.Medium);
query.Abort();
}
return containers;
}
private void ExecuteGoToAlbum(TrackContainer album)
{
UriQuery q = new UriQuery();
q.Add("artistName", album.Owner.Name);
q.Add("albumName", album.Name);
RegionManager.RequestNavigate(AppRegions.ViewRegion, typeof(AlbumView).FullName + q);
}
