public async Task <ActionResult <object> > GetAlbum([FromQuery] SpotifyAlbum album)
{
SpotifyClientCredentialsAuthService.StartCredentialsAuth();
var albumData = SpotifyClientCredentialsAuthService.GetAlbums(album.Id);
return(Ok(albumData));
}
public static Album CreateAlbum(SpotifyAlbum inAlbum)
{
return(new Album
{
Uri = inAlbum.Uri,
Name = inAlbum.Name,
Id = inAlbum.Id,
Type = inAlbum.Type,
Images = ConvertImageList(inAlbum.Images),
AlbumType = inAlbum.AlbumType,
Artists = CreateArtists(inAlbum.Artists),
AvailableMarkets = inAlbum.AvailableMarkets,
Href = inAlbum.Href
});
}
public async Task HasAGetSaleQueryResultAsync()
{
var spotifyAlbum = new SpotifyAlbum {
Id = "teste", Name = "Fake Teste", ReleaseDate = DateTime.Now.ToShortDateString(), TotalTracks = 10
};
var spotifyServiceMock = new Mock <ISpotifyService>();
spotifyServiceMock.Setup(x => x.GetAlbumAsync(It.IsAny <string>())).ReturnsAsync(spotifyAlbum);
var queryResult = await new GetAlbumQueryHandler(spotifyServiceMock.Object).Handle(new GetAlbumQuery(spotifyAlbum.Id), new CancellationToken());
Assert.NotNull(queryResult);
Assert.Equal(spotifyAlbum.Id, queryResult.Id);
Assert.True(queryResult.Price > 0);
}
public async Task SinglesListView_ItemClick(SpotifyAlbum single)
{
SpotifyAlbum fullSingle = await AppConstants.SpotifyClient.GetAlbum(single.Id);
navigationService.NavigateTo(nameof(AlbumDetailPage), fullSingle);
}
public async Task AlbumsListView_ItemClick(SpotifyAlbum album)
{
SpotifyAlbum fullAlbum = await AppConstants.SpotifyClient.GetAlbum(album.Id);
navigationService.NavigateTo(nameof(AlbumDetailPage), fullAlbum);
}
public async Task TracksListView_ItemClick(SavedTrack track)
{
SpotifyAlbum fullAlbum = await AppConstants.SpotifyClient.GetAlbum(track.Track.Album.Id);
navigationService.NavigateTo(nameof(AlbumDetailPage), fullAlbum);
}
public async Task <ActionResult> Post([FromBody] DiscographyPostData bodyObj)
{
try
{
// Obtener Albums
List <Album> albumsList = ds.getAlbumsFromBase64File(bodyObj.File);
// Ordenar los datos
List <Album> orderedAlbums = albumsList.OrderBy(album => album.Year).ThenBy(album => album.Title).ToList();
// Preparar los datos (Obtener décadas de discos)
var groupedByDecade = orderedAlbums.GroupBy(album => Utils.Utils.GetDecade(album.Year)).OrderByDescending(x => Utils.Utils.GetDecade(x.Key));
// Crear tablero de Trello
CrearTableroResult tablero = ts.CrearTablero(bodyObj.DashboardTitle);
if (tablero != null)
{
// Crear listas de décadas en tablero de Trello
foreach (var decade in groupedByDecade)
{
CrearListaResult lista = ts.CrearLista(tablero.Id, String.Format("{0}s'", decade.Key.ToString()));
foreach (var album in decade)
{
// Crear tarjeta para el album
string tarjetaName = album.Year + " - " + album.Title;
CrearTarjetaResult tarjeta = ts.CrearTarjeta(lista.Id, tarjetaName);
// Obtener imagen del album de Spotify
SpotifyAlbumSearch albumsResult = ss.searchAlbumsByTitle(album.Title);
if (albumsResult != null)
{
SpotifyAlbum albumFound = albumsResult.albums.Items
.Where(x => x.Artists.FirstOrDefault().Name.ToLower().Equals("Bob Dylan".ToLower()))
.Where(x => Utils.Utils.homologarComilllas(x.Name).ToLower().Equals(Utils.Utils.homologarComilllas(album.Title).ToLower()))
.FirstOrDefault();
if (albumFound != null)
{
SpotifyImage albumImage = albumFound.images.Where(x => x.Width == 300).FirstOrDefault();
// Adjuntar imagen a la portada
SpotifyImage attachedImage = ts.AdjuntarPortada(tarjeta.Id, albumImage.Url, "img_" + tarjetaName.Replace(" ", ""));
}
else
{
// Registrar de que albums no se encontraron portadas
var t = album.Title;
}
}
}
}
}
return(Ok());
}
catch (Exception Ex)
{
throw Ex;
}
}
public void AlbumsListView_ItemClick(SpotifyAlbum album)
{
navigationService.NavigateTo(nameof(AlbumDetailPage), album);
}
public async Task OnNavigatedTo(SpotifyAlbum album)
{
Tracks = new ObservableCollection <SavedTrack>();
this.album = album;
AlbumImageUrl = new Uri(album.GetLargestImage().Url);
AlbumName = album.Name;
AlbumArtist = string.Join(", ", album.Artists.Select(artist => artist.Name));
DateTimeOffset releaseDate = HelperMethods.ParseReleaseDate(album.ReleaseDate);
if (album.ReleaseDatePrecision == "year")
{
ReleaseDate = releaseDate.Year.ToString();
}
else if (album.ReleaseDatePrecision == "month")
{
ReleaseDate = releaseDate.ToString("y");
}
else if (album.ReleaseDatePrecision == "day")
{
ReleaseDate = releaseDate.ToString("d");
}
if (album.Tracks.Total == 1)
{
NumSongs = $"{album.Tracks.Total} song";
}
else
{
NumSongs = $"{album.Tracks.Total} songs";
}
SavedSaveText = "Saved";
TimeSpan albumLength = TimeSpan.Zero;
SpotifyPagingObject <SpotifyTrack> tracksPaging = album.Tracks;
List <bool> savedTracks = await AppConstants.SpotifyClient.GetSavedTracks(tracksPaging.Items.Select(track => track.Id).ToList());
for (int i = 0; i < tracksPaging.Items.Count; i++)
{
SavedTrack savedTrack = new SavedTrack()
{
Track = tracksPaging.Items[i],
Saved = savedTracks[i]
};
Tracks.Add(savedTrack);
albumLength += TimeSpan.FromMilliseconds(savedTrack.Track.Duration);
}
while (tracksPaging.Next != null)
{
tracksPaging = await AppConstants.SpotifyClient.GetNextPage(tracksPaging);
savedTracks = await AppConstants.SpotifyClient.GetSavedTracks(tracksPaging.Items.Select(track => track.Id).ToList());
for (int i = 0; i < tracksPaging.Items.Count; i++)
{
SavedTrack savedTrack = new SavedTrack()
{
Track = tracksPaging.Items[i],
Saved = savedTracks[i]
};
Tracks.Add(savedTrack);
albumLength += TimeSpan.FromMilliseconds(savedTrack.Track.Duration);
}
}
AlbumLength = albumLength.MinimalToString();
}
public async Task <IEnumerable <SpotifyTrack> > GetAlbumTracks(SpotifyAlbum album)
{
return(await GetAlbumTracks(album.Id));
}
public SpotifyAlbumViewModel(SpotifyAlbum album)
{
_album = album;
}
