public async Task SpotifyPlaylist(CommandContext ctx, string uri) { FullAlbum album = await global.spotify.Albums.Get(uri.Split(":").Last()); if (album.Tracks.Items.Count != 0) { await ctx.Message.Channel.SendMessageAsync("Loading playlist..."); if (await global.lavaPlayer.Join(ctx)) { List <LavalinkTrack> tracks = new List <LavalinkTrack>(album.Tracks.Items.Count); foreach (SimpleTrack track in album.Tracks.Items) { LavalinkTrack lavaTrack = await LavaPlayer.SearchToTrack(ctx, $"{track.Name} - {track.Artists[0].Name}"); if (lavaTrack != null) { tracks.Add(lavaTrack); } } tracks.TrimExcess(); await global.lavaPlayer.PlayTracksList(ctx, tracks); } } else { await ctx.Message.Channel.SendMessageAsync("Invalid link!"); } }
public void MapSpotifyAlbumToTrack(Track track, FullAlbum spotifyAlbum) { track.AlbumArtists = GetAlbumArtistFromSimpleArtistList(spotifyAlbum.Artists); track.Album = spotifyAlbum.Name; track.Genres = spotifyAlbum.Genres.ToArray(); if (DateTime.TryParse(spotifyAlbum.ReleaseDate ?? "", out var date)) { track.Year = date.Year; } if (spotifyAlbum.Images?.Count > 0) { var sorted = spotifyAlbum.Images.OrderByDescending(i => i.Width).ToList(); if (sorted.Count > 0) { track.ArtExtraLargeUrl = sorted[0].Url; } if (sorted.Count > 1) { track.ArtLargeUrl = sorted[1].Url; } if (sorted.Count > 2) { track.ArtMediumUrl = sorted[2].Url; } if (sorted.Count > 3) { track.ArtSmallUrl = sorted[3].Url; } } }
public static List <Track> GetAlbumTracks(string albumId) { Paging <SimpleTrack> album = _spotify.GetAlbumTracks(albumId); FullAlbum albumInfo = _spotify.GetAlbum(albumId); List <Track> tracks = new List <Track>(); foreach (SimpleTrack track in album.Items) { string artists = ""; track.Artists.ForEach(artist => artists += artist.Name + ","); tracks.Add(new Track() { SongTitle = track.Name, Album = albumInfo.Name, Artists = artists, TrackNumber = track.TrackNumber, DiscNumber = track.DiscNumber, Year = albumInfo.ReleaseDate, CoverLink = new Uri(albumInfo.Images[0].Url), Status = -1, Progress = 0, Platform = Agent.Spotify }); } return(tracks); }
internal void MapSpotifyAlbumToTrackMissingImages_ReturnsExpectedTrack() { var fullAlbum = new FullAlbum { Artists = new List <SimpleArtist> { new SimpleArtist { Name = "Artist" }, new SimpleArtist { Name = "Other Artist" } }, Name = "Album Name", Genres = new List <string> { "Reggae", "Rock", "Jazz" }, ReleaseDate = "2010-10-10", Images = new List <Image>() }; _spotifyAPI.MapSpotifyAlbumToTrack(_track, fullAlbum); Assert.Equal(new[] { "Artist", "Other Artist" }, _track.AlbumArtists); Assert.Equal("Album Name", _track.Album); Assert.Equal(new[] { "Reggae", "Rock", "Jazz" }, _track.Genres); Assert.Equal(2010, _track.Year); Assert.Null(_track.ArtExtraLargeUrl); Assert.Null(_track.ArtLargeUrl); Assert.Null(_track.ArtMediumUrl); Assert.Null(_track.ArtSmallUrl); }
public SpotifyCollection(FullAlbum album, IEnumerable <SpotifyTrack> items) { Items = items; Images = album.Images.Select(image => image.Url) .ToArray(); Authors = album.Artists.ToDictionary( artist => artist.Name, artist => { try { return(new Uri(artist.ExternalUrls["spotify"])); } catch (KeyNotFoundException) // Should never fail { return(new Uri(artist.Uri)); } }); ExternUrls = new Dictionary <string, Uri>( album.ExternalUrls.Select( pair => new KeyValuePair <string, Uri>(pair.Key, new Uri(pair.Value)))); // Convert value to URI Id = album.Id; Name = album.Name; Type = album.Type; try { Uri = ExternUrls["spotify"]; } catch (KeyNotFoundException) // Should never fail { // Convert Spotify URI to a track link (wont link track to playlist or album if it was linked) Uri = new Uri(album.Uri); } }
public IMusic ParseUri(string uri) { //https://open.spotify.com/track/2fTdRdN73RgIgcUZN33dvt //https://open.spotify.com/album/2N367tN1eIXrHNVe86aVy4?si=A-1kS4F4Tfy2I_PYEDVhMA //https://open.spotify.com/artist/5cj0lLjcoR7YOSnhnX0Po5 uri = NormalizeSpotifyUri(uri); string[] uriParts = uri.Split("/"); if (uriParts.Contains("track")) { FullTrack sTrack = ConverterBot.Clients.SpotifyClient.Tracks.Get(uriParts.Last( )).Result; return(new Track(sTrack.Name, sTrack.Artists.First( ).Name, sTrack.Album.Name, 0, sTrack.Id)); } if (uriParts.Contains("album")) { string id; if (uriParts.Last( ).Contains("?")) { id = uriParts.Last( ).Split("?").First( ); } else { id = uriParts.Last( ); } FullAlbum sAlbum = ConverterBot.Clients.SpotifyClient.Albums.Get(id).Result; return(new Album(sAlbum.Name, sAlbum.Artists.First( ).Name, sAlbum.ReleaseDate, sAlbum.Id)); } if (uriParts.Contains("artist")) { FullArtist sArtist = ConverterBot.Clients.SpotifyClient.Artists.Get(uriParts.Last( )).Result; List <SimpleAlbum>?sArtistAlbums = ConverterBot.Clients.SpotifyClient.Artists.GetAlbums(uriParts.Last( )).Result.Items; SimpleAlbum sSampleAlbum = sArtistAlbums?.First( ); Album sampleAlbum = new Album(sSampleAlbum?.Name, sArtist.Name, sSampleAlbum?.ReleaseDate, sSampleAlbum?.Id); return(new Artist(sArtist.Name, sampleAlbum, null, sArtist.Id)); } return(null); }
// GET: Musics/MusicDetails/5 public ActionResult MusicDetails(string Id) { List <MusicModels> musics = db.Musics.ToList(); foreach (var m in musics) { if (m.ID.ToString() == Id) { return(View(db.Musics.Include(mu => mu.ID_Album).Where(mu => mu.ID.ToString().Equals(Id)).First())); } } FullTrack track = _spotify.GetTrack(Id); FullAlbum album = null; ViewBag.Boolean = IsBuy(User.Identity.GetUserId().ToString(), Id); MusicModels v = new MusicModels { ID_Spotify = Id, Title = track.Name, prix = track.Popularity / 7, Note = track.Popularity, ID_User = track.Artists, PreviewUrl = track.PreviewUrl, }; if (track.Album != null) { album = _spotify.GetAlbum(track.Album.Id); v.Album = album.Name; v.ReleaseDate = DateTime.Parse(album.ReleaseDate); } return(View(v)); }
public void MapSpotifyAlbumToTrack(Track track, FullAlbum spotifyAlbum) { track.AlbumArtists = spotifyAlbum.Artists.Select(a => a.Name).ToArray(); track.Album = spotifyAlbum.Name; track.Genres = spotifyAlbum.Genres.ToArray(); if (uint.TryParse(spotifyAlbum.ReleaseDate?.Substring(0, 4), out var year)) { track.Year = year; } if (spotifyAlbum.Images.Count > 0) { var sorted = spotifyAlbum.Images.OrderByDescending(i => i.Width).ToList(); if (sorted.Count > 0) { track.ArtExtraLargeUrl = sorted[0].Url; } if (sorted.Count > 1) { track.ArtLargeUrl = sorted[1].Url; } if (sorted.Count > 2) { track.ArtMediumUrl = sorted[2].Url; } if (sorted.Count > 3) { track.ArtSmallUrl = sorted[3].Url; } } }
public static async Task <List <Track> > IndexNewAlbumTracksAsync( Guid albumId, FullAlbum album, IEnumerable <Artist> albumArtists, IRepositoryManager repositoryManager, IMapper mapper, SpotifyAPICredentials spotifyAPICredentials) { List <Track> newAlbumTracks = new List <Track>(); HashSet <string> albumArtistsSpotifyIds = albumArtists.Select(a => a.SpotifyId).ToHashSet(); foreach (var track in album.Tracks.Items) { var newTrack = new Track { SpotifyId = track.Id, AlbumId = albumId, Name = track.Name, TrackNumber = (short)track.TrackNumber, DiscNumber = (byte)track.DiscNumber, Duration = track.DurationMs }; newTrack.TrackArtists = await MapTrackArtistsAsync( track, albumArtistsSpotifyIds, albumArtists, repositoryManager, mapper, spotifyAPICredentials).ConfigureAwait(false); } return(newAlbumTracks); }
private async Task <(FullAlbum album, IEnumerable <SpotifyTrackInfo> infos)> GetSpotifyInfos(string id, int startIndex, int maxResults) { FullAlbum album = await this.RunConfig.Api.GetAlbumAsync(id); IEnumerable <SpotifyTrackInfo> sourceTracks = album.Tracks.Items.Select(track => new SpotifyTrackInfo(track)); IEnumerable <SpotifyTrackInfo> infos = await SpotifyCollectionHandler.GetAllSpotifyInfosAsync(sourceTracks, id, new CollectionOptions(album.Tracks.Total, startIndex, maxResults), this.CollectionGetter); return(album, infos); }
private static DateTime GetDateTime(FullAlbum album) { if (album.ReleaseDatePrecision != "year") { return(DateTime.Parse(album.ReleaseDate)); } var year = int.Parse(album.ReleaseDate); return(new DateTime(year, 1, 1)); }
public static Album ToAlbum(this FullAlbum fullAlbum) { var album = new Album { ProviderId = "spotify." + fullAlbum.Id, Name = fullAlbum.Name.Trim().Replace(" ", " "), ReleaseDate = GetDateTime(fullAlbum) }; return(album); }
public string ReturnSongFromAlbum(FullAlbum album, string cancion) { foreach (SimpleTrack track in album.Tracks.Items) { if (track.Name == cancion) { return(track.Id); } } return(string.Empty); }
public ErrorResponse ReproducirCancion(string uri, CancionLarga cl) { FullAlbum album = _spotify.GetAlbum(uri); List <string> uris = new List <string>(); foreach (Cancion parte in cl.Partes) { uris.Add("spotify:track:" + DevolverCancionDelAlbum(uri, parte.titulo)); } return(_spotify.ResumePlayback(uris: uris, offset: "", positionMs: 0)); }
public void procesarAlbum(FullAlbum album) { String[] parseFecha = album.ReleaseDate.Split('-'); string portada = album.Name + "_" + album.Artists[0].Name + ".jpg"; foreach (char ch in CaracteresProhibidosWindows) { if (portada.Contains(ch.ToString())) { portada = portada.Replace(ch.ToString(), string.Empty); } } using (System.Net.WebClient cliente = new System.Net.WebClient()) { try { System.IO.Directory.CreateDirectory(Environment.CurrentDirectory + "/covers"); cliente.DownloadFile(new Uri(album.Images[0].Url), Environment.CurrentDirectory + "/covers/" + portada); } catch (System.Net.WebException) { System.Windows.Forms.MessageBox.Show(""); portada = ""; } } Album a = new Album(album.Name, album.Artists[0].Name, Convert.ToInt16(parseFecha[0]), Convert.ToInt16(album.TotalTracks), Environment.CurrentDirectory + "/covers/" + portada); //creamos A if (Programa.miColeccion.estaEnColeccion(a)) { Log.Instance.ImprimirMensaje("Intentando añadir duplicado, cancelando...", TipoMensaje.Advertencia); throw new InvalidOperationException(); } a.SetSpotifyID(album.Id); List <Cancion> canciones = new List <Cancion>(a.numCanciones); List <SimpleTrack> c = _spotify.GetAlbumTracks(album.Id, a.numCanciones).Items; for (int i = 0; i < c.Count; i++) { canciones.Add(new Cancion(c[i].Name, new TimeSpan(0, 0, 0, 0, c[i].DurationMs), ref a)); if (canciones[i].duracion.Milliseconds > 500) { canciones[i].duracion += new TimeSpan(0, 0, 0, 0, 1000 - canciones[i].duracion.Milliseconds); } else { canciones[i].duracion -= new TimeSpan(0, 0, 0, 0, canciones[i].duracion.Milliseconds); } a.duracion += canciones[i].duracion; } a.canciones = canciones; a.LevantarBorrado(); Programa.miColeccion.agregarAlbum(ref a); }
public static Album ToAlbum(this FullAlbum fullAlbum) { var album = new Album { ProviderId = "spotify." + fullAlbum.Id, Name = fullAlbum.Name.Trim().Replace(" ", " "), ReleaseDate = GetDateTime(fullAlbum), Genre = fullAlbum.Genres != null?fullAlbum.Genres.FirstOrDefault() : "" }; return(album); }
public async Task <Release> GetReleaseById(string id) { FullAlbum album = await dataLayer.ExecuteQuery(new AlbumByIdQuery(id)); SimpleArtist artist = album.Artists.First(); return(new Release( id, name: album.Name, artistId: artist.Id, artistName: artist.Name, url: album.ExternalUrls["spotify"])); }
public string DevolverCancionDelAlbum(string uri, string cancion) { FullAlbum album = _spotify.GetAlbum(uri); foreach (SimpleTrack track in album.Tracks.Items) { if (track.Name == cancion) { return(track.Id); } } return(string.Empty); }
public void GetRecommendations() { Debug.Log("GetRecommendations called"); if (activeSeeds.Count > 0) { List <string> artistIds = new List <string>(); List <string> trackIds = new List <string>(); foreach (var seed in activeSeeds) { PlaylistScript playlistScript = seed.GetComponent <VinylScript>().playlistScript; if (playlistScript.trackType == PlaylistScript.TrackType.artist) { artistIds.Add(playlistScript.artistId); } else if (playlistScript.trackType == PlaylistScript.TrackType.playlist) { FullPlaylist fullPlaylist = spotifyManagerScript.GetPlaylist(playlistScript.ownerId, playlistScript.playlistId); artistIds.Add(fullPlaylist.Tracks.Items[0].Track.Artists[0].Id); } else if (playlistScript.trackType == PlaylistScript.TrackType.track) { trackIds.Add(playlistScript.trackId); } else if (playlistScript.trackType == PlaylistScript.TrackType.album) { FullAlbum fullAlbum = spotifyManagerScript.GetAlbum(playlistScript.albumId); artistIds.Add(fullAlbum.Artists[0].Id); } else { Debug.LogError("Unsupported track type"); } } if (artistIds.Count != 0) { StartCoroutine(userRecommendations.LoadUserRecommendationsWithArtist(artistIds)); } else if (trackIds.Count != 0) { StartCoroutine(userRecommendations.LoadUserRecommendationsWithTrack(trackIds)); } else { Debug.LogError("Seed Id list is empty"); } } }
public static async Task <FullAlbum> GetAlbumWithoutExceptionAsync(this SpotifyWebAPI api, string id) { FullAlbum album = null; try { album = await api.GetAlbumAsync(id); } catch { // ignored } return(album); }
private void CreatePlaylist(List <string> tracks) { FullPlaylist newReleases = spotify.CreatePlaylist(profile.Id, DateTime.Now.ToString("MM/dd") + " Releases"); SearchItem song = new SearchItem(); ErrorResponse response = new ErrorResponse(); if (newReleases.HasError()) //This might need more graceful integration { Console.WriteLine(newReleases.Error.Message); } foreach (string target in tracks) { if (target.Contains("EP") || target.Contains("Album") || target.Contains("Remixes")) { song = spotify.SearchItems(target, SearchType.Album); if (song.Albums.Total > 0) { FullAlbum album = spotify.GetAlbum(song.Albums.Items[0].Id); for (int i = 0; i < album.Tracks.Total; i++) { response = spotify.AddPlaylistTrack(profile.Id, newReleases.Id, album.Tracks.Items[i].Uri); playlistsListBox.Items.Add(album.Tracks.Items[i].Name); } } } else { song = spotify.SearchItems(target, SearchType.Track); if (song.Tracks.Items.Count > 0) { response = spotify.AddPlaylistTrack(profile.Id, newReleases.Id, song.Tracks.Items[0].Uri); playlistsListBox.Items.Add(song.Tracks.Items[0].Name); } if (response.HasError()) //This might need more graceful integration { Console.WriteLine(response.Error.Message); } } } MessageBox.Show("Playlist Created!"); if (response.HasError()) //This might need more graceful integration { Console.WriteLine(response.Error.Message); } }
private void lstAlbum_SelectionChanged(object sender, SelectionChangedEventArgs e) { lstSong.Items.Clear(); txtbDesc.Inlines.Clear(); string cid = "84654d712193471199189e4f593781dc"; string sid = "ab7ead187ddd4f0aaa17542b26ca8d5e"; ClientCredentialsAuth C = new ClientCredentialsAuth() { ClientId = cid, ClientSecret = sid, }; Token T = C.DoAuth(); SpotifyWebAPI Spot1 = new SpotifyWebAPI() { UseAuth = true, AccessToken = T.AccessToken, UseAutoRetry = true, TokenType = T.TokenType, }; try { var selection = (SimpleAlbum)((ListBoxItem)lstAlbum.SelectedItem).Tag; Paging <SimpleTrack> st = Spot1.GetAlbumTracks(selection.Id); st.Items.ForEach(x => lstSong.Items.Add(x.Name)); FullAlbum imgs = Spot1.GetAlbum(selection.Id); BitmapImage img = new BitmapImage(); img.BeginInit(); img.UriSource = new Uri(imgs.Images[0].Url); img.EndInit(); imgalbum.Source = img; txtbDesc.Inlines.Add($"Popularity rating: {imgs.Popularity.ToString()}\nReleased on: {imgs.ReleaseDate}"); //txtbDesc.Inlines.Add($""); } catch (Exception ex) { MessageBox.Show(ex.Message); lstArtist.Items.Clear(); lstAlbum.Items.Clear(); lstSong.Items.Clear(); } }
internal void MapSpotifyAlbumToTrackMissingImageSizes_ReturnsExpectedTrack() { var fullAlbum = new FullAlbum() { Artists = new List <SimpleArtist>() { new SimpleArtist { Name = "Artist" }, new SimpleArtist { Name = "Other Artist" } }, Name = "Album Name", Genres = new List <string>() { "Reggae", "Rock", "Jazz" }, ReleaseDate = "2010-10-10", Images = new List <SpotifyAPI.Web.Models.Image>() { new SpotifyAPI.Web.Models.Image() { Height = 64, Width = 64, Url = "http://64x64.img", }, new SpotifyAPI.Web.Models.Image() { Height = 256, Width = 256, Url = "http://256x256.img", }, } }; _spotifyAPI.MapSpotifyAlbumToTrack(_track, fullAlbum); Assert.Equal(new[] { "Artist", "Other Artist" }, _track.AlbumArtists); Assert.Equal("Album Name", _track.Album); Assert.Equal(new[] { "Reggae", "Rock", "Jazz" }, _track.Genres); Assert.Equal(2010, _track.Year); Assert.Equal("http://256x256.img", _track.ArtExtraLargeUrl); Assert.Equal("http://64x64.img", _track.ArtLargeUrl); Assert.Null(_track.ArtMediumUrl); Assert.Null(_track.ArtSmallUrl); }
public IEnumerator Test_Spotify_GetAlbum() { Spotify spotify = new Spotify(); spotify.TestSetup(); #if UNITY_IPHONE //Big Fish Theory string albumId = "1qnEwPuG3l4PqRu8h3ULH7"; FullAlbum fullAlbum = spotify.GetAlbum(albumId); yield return(null); Debug.Log(fullAlbum.Name); Assert.IsFalse(fullAlbum.HasError()); }
public async Task <ActionResult> EditResult(FullAlbum model, HttpPostedFileBase coverfile) { if (model != null && ModelState.IsValid) { if (coverfile != null) { string fileName = System.IO.Path.GetFileName(coverfile.FileName); coverfile.SaveAs(Server.MapPath("~/Content/img/covers/" + fileName)); model.Album.AlbumCover = fileName; } await _commonService.UpdateThis(model.Album); return(RedirectToAction("ViewAlbum", new { id = model.Album.AlbumId })); } return(HttpNotFound()); }
public void PlaySong(string uri, LongSong cl) { try { FullAlbum album = SpotifyClient.Albums.Get(uri).Result; List <string> uris = new List <string>(); foreach (Song parte in cl.Parts) { uris.Add("spotify:track:" + ReturnSongFromAlbum(album, parte.Title)); } PlaySong(uris); } catch (APIException ex) { throw ex; } }
public static async Task SaveSpotifyAlbumLevel1(FullAlbum album) { if (!App.Locator.Setting.IsLoggedIn) { if (_warningCount > 0) { ToastManager.ShowError("Login required."); return; } await MessageHelpers.LoginRequired(); _warningCount += 1; } App.Locator.PBar.IsEnable = true; try { if (album != null) { foreach (var obj in album.Tracks.Items) { var fTrack = obj; obj.Name = obj.Name.GetSongNameFromMain(); obj.Artist.Name = obj.Artist.Name.GetArtistName(); if (obj.Name == "Unknown Track") { obj.Name = fTrack.Name; } if (obj.Artist.Name == "Unknown Artist" && fTrack.Artist.Name != "Unknown Artist") { obj.Artist.Name = fTrack.Artist.Name; } } } await SpotifySavingHelper.SaveSpotifyAlbumLevel1(album); } catch { await SpotifySavingHelper.SaveSpotifyAlbumLevel1(album); } App.Locator.PBar.IsEnable = false; }
private WebAlbum CreateAlbum(FullAlbum album) { var webAlbum = CreateAlbum(album as SimpleAlbum); webAlbum.IsPartial = false; webAlbum.Tracks = album.Tracks?.Items?.Select(CreateSong).ToList(); webAlbum.Artist = CreateArtist(album.Artist); webAlbum.Genres = album.Genres; DateTime released; if (DateTime.TryParse(album.ReleaseDate, out released)) { webAlbum.ReleaseDate = released; } return(webAlbum); }
public void insertarAlbumFromURI(string uri) { Log.Instance.ImprimirMensaje("Insertando álbum con URI " + uri, TipoMensaje.Info); Stopwatch crono = Stopwatch.StartNew(); FullAlbum sa = _spotify.GetAlbum(uri); try { procesarAlbum(sa); } catch (Exception) { return; } crono.Stop(); Log.Instance.ImprimirMensaje("Añadido", TipoMensaje.Correcto, crono); Programa.refrescarVista(); }
// GET: Albums/Details/5 public ActionResult Details(string id) { int albumID = int.Parse(id); AlbumModels alb = db.Albums.Include(a => a.Musics).Where(a => a.ID == albumID).First(); return(View(alb)); FullAlbum album = _spotify.GetAlbum(id); AlbumModels v = new AlbumModels { Title = album.Name, Genre = album.Genres, ID_User = album.Artists, Note = album.Popularity }; return(View(v)); }