public static Playlist CreatePlaylist(SpotifyPlaylist inPlaylist) { return(new Playlist { Id = inPlaylist.Id, Uri = inPlaylist.Uri, Name = inPlaylist.Name, Images = ConvertImageList(inPlaylist.Images), Owner = CreateUserData(inPlaylist.Owner), Tracks = CreatePlaylistTracksInfo(inPlaylist.PlaylistTracks) }); }
public SpotifyPlaylist GetPlaylist(string name) { List <SpotifyPlaylist> all = GetAllPlaylists().Result; foreach (var item in all) { _Log.Info(item.name); } SpotifyPlaylist toReturn = all.FirstOrDefault(p => p.name.Equals(name)); return(toReturn); }
/// <summary> /// API: https://developer.spotify.com/documentation/web-api/reference/#/operations/reorder-or-replace-playlists-tracks /// /// Header: /// { /// "range_start": 1, /// "insert_before": 3, /// "range_length": 2 /// } /// /// Scope: /// Had to add: playlist-modify-public /// </summary> public void SortPlaylist(SpotifyPlaylist playlist) { dynamic postData = new System.Dynamic.ExpandoObject(); postData.range_start = 13; postData.insert_before = 0; string header = JsonConvert.SerializeObject(postData); string url = string.Format("https://api.spotify.com/v1/playlists/{0}/tracks", playlist.id); string json = HttpHelper.Put(url, this.AuthenticationToken, header).Result; CheckForResponseErrors(json); }
public async Task <SpotifyPlaylist> GetPlaylist(SpotifyPlaylist playlist) { try { if (playlist != null) { JObject result = await this.GetJObjectAsync(string.Format("users/{0}/playlists/{1}", this.Profile.ID, playlist.ID)); return(new SpotifyPlaylist(result)); } } catch (Exception ex) { Logger.Log(ex); } return(null); }
public async Task <bool> AddSongToPlaylist(SpotifyPlaylist playlist, SpotifySong song) { try { if (playlist != null && song != null) { HttpResponseMessage response = await this.PostAsync(string.Format("users/{0}/playlists/{1}/tracks?uris=spotify:track:" + song.ID, this.Profile.ID, playlist.ID), null); return(response.StatusCode == HttpStatusCode.Created); } } catch (Exception ex) { Logger.Log(ex); } return(false); }
public ActionResult AboutMe() { var model = new AboutMeModel(); var spotify = new SpotifyPlaylist(); StreamLineDataEntities context = new StreamLineDataEntities(); var user = context.AspNetUsers.Single(u => u.Email == User.Identity.Name); model.FirstName = user.FirstName; model.LastName = user.LastName; model.BirthDate = user.BirthDate.ToString(); model.AboutMe = user.AboutMe; spotify.SpotifyPlaylistURL = user.SpotifyPlaylistUri; return(View(model)); }
private IEnumerable <SpotifyPlaylist> Map(List <SimplePlaylist> items) { var result = new List <SpotifyPlaylist>(); foreach (var item in items) { var itemResult = new SpotifyPlaylist(); itemResult.Id = item.Id; itemResult.Name = item.Name; itemResult.OwnerId = item.Owner.Id; result.Add(itemResult); } return(result); }
public void SortPlaylist(string playlistName) { SpotifyPlaylist spotifyPlaylist = _spotify.PlaylistExists(playlistName); if (spotifyPlaylist == null) { // Abort if playlist already exists _Log.InfoFormat("Playlist does not exist,{0}", playlistName); } else { // Sort _spotify.SortPlaylist(spotifyPlaylist); } }
public async Task <IEnumerable <SpotifySong> > GetPlaylistSongs(SpotifyPlaylist playlist) { List <SpotifySong> results = new List <SpotifySong>(); try { if (playlist != null) { foreach (JObject song in await this.GetPagedResult(string.Format("users/{0}/playlists/{1}/tracks", this.Profile.ID, playlist.ID))) { results.Add(new SpotifySong((JObject)song["track"])); } } } catch (Exception ex) { Logger.Log(ex); } return(results); }
public async Task <bool> PlayPlaylist(SpotifyPlaylist playlist) { try { JObject payload = new JObject(); payload["context_uri"] = playlist.Uri; JObject position = new JObject(); position["position"] = 0; payload["offset"] = position; HttpResponseMessage response = await this.PutAsync("me/player/play", this.CreateContentFromObject(payload)); return(response.StatusCode == HttpStatusCode.NoContent); } catch (Exception ex) { Logger.Log(ex); } return(false); }
public ActionResult ProfilePageView() { StreamLineDataEntities context = new StreamLineDataEntities(); var user = context.AspNetUsers.Single(u => u.Email == User.Identity.Name); APIDataService api = new APIDataService(); DataModels model = new DataModels(); SpotifyPlaylist playlist = new SpotifyPlaylist(); playlist.SpotifyPlaylistURL = user.SpotifyPlaylistUri; model.DataModel = api.GetAllInfo(user.TwitterConnect, user.InstagramConnect); model.WebPlayer = playlist; return(View(model)); }
public void SpotifyClient_GetTracksForPlaylist() { SpotifyClient client = new SpotifyClient(creds); SpotifyPlaylist playlist = null; SpotifyPlaylistTracksRequest tracksRequest = null; SpotifyPlaylistTracksResponse tracksResponse = null; if (client.Connected) { playlist = client.GET <SpotifyPlaylistsResponse>(new SpotifyPlaylistsRequest()).Items.FirstOrDefault(); tracksRequest = new SpotifyPlaylistTracksRequest() { Playlist_ID = playlist.ID }; tracksResponse = client.GET <SpotifyPlaylistTracksResponse>(tracksRequest); Console.WriteLine("test"); } }
public void CreatePlaylist(string playlistName) { // Abort if playlist already exists if (_spotify.PlaylistExists(playlistName) != null) { _Log.InfoFormat("Playlist already exists,{0}", playlistName); return; } // Get playlist from iTunes IList <Playlist> playlists = _iTunes.GetPlaylists(); Playlist songsToImport = playlists.FirstOrDefault(p => p.Name == playlistName); _iTunes.LoadPlaylist(songsToImport); // Create Spotify playlist and populate it SpotifyPlaylist spotifyPlaylist = _spotify.CreatePlaylist(playlistName, false).Result; _spotify.AddSongsToPlaylist(spotifyPlaylist, songsToImport.Songs); }
public async Task <SpotifyPlaylist> CreatePlaylist(string name, bool isPublic) { _Log.InfoFormat("Creating playlist,{0}", name); dynamic postData = new System.Dynamic.ExpandoObject(); postData.name = name; postData.@public = isPublic; string header = JsonConvert.SerializeObject(postData); string json = await HttpHelper.Post("https://api.spotify.com/v1/me/playlists", this.AuthenticationToken, header); CheckForResponseErrors(json); SpotifyPlaylist toReturn = JsonConvert.DeserializeObject <SpotifyPlaylist>(json, new JsonSerializerSettings()); _Log.InfoFormat("Playlists created,{0} [ID: {1}]", toReturn.name, toReturn.id); return(toReturn); }
public async Task <IEnumerable <SpotifySong> > GetSongsForPlaylists(SpotifyPlaylist playlist) { var getResult = await _api.Api.GetPlaylistTracksAsync(playlist.OwnerId, playlist.Id, limit : 200); if (getResult.HasError()) { throw new Exception($"{getResult.Error.Status}: {getResult.Error.Message}"); } var result = new List <SpotifySong>(); foreach (var item in getResult.Items) { var song = new SpotifySong(item.Track.Name, new Uri(item.Track.Album.Images.First().Url, UriKind.Absolute), new TimeSpan(item.Track.DurationMs), new Uri(item.Track.Uri, UriKind.Absolute)); result.Add(song); } return(result); }
public void TestSpotifyAdapter_CreatePlaylistFromCsvFileAsync() { string playlistFile = GetFullPath("Basic_Playlist.txt"); CsvPlaylistRepo repo = new CsvPlaylistRepo(); Playlist songsToImport = repo.GetSongList(playlistFile); SpotifyAdapter spotify = new SpotifyAdapter(new SettingsFacade()); SpotifyPlaylist playlist = spotify.GetPlaylist(PLAYLIST_TO_CREATE); if (playlist == null) { playlist = spotify.CreatePlaylist(PLAYLIST_TO_CREATE, false).Result; Assert.AreEqual(PLAYLIST_TO_CREATE, playlist.name); } spotify.AddSongsToPlaylist(playlist, songsToImport.Songs); SpotifyPlaylist playlistNew = spotify.GetPlaylist(PLAYLIST_TO_CREATE); Assert.IsNotNull(playlistNew); Assert.IsNotNull(playlistNew.tracks); Assert.AreEqual(songsToImport.Songs.Count, playlistNew.tracks.total); }
/* * public void UpdateSpotifyPlaylist() * { * var client = new RestClient(Constants.Spotify.WebApiBase + "playlists/"); * var request = new RestRequest(spotifyPlaylist.id, Method.GET); * request.RequestFormat = DataFormat.Json; * request.AddHeader("Authorization", "Bearer " + credentials.accessToken); * IRestResponse response = client.Execute(request); * if(response.IsSuccessful) * { * spotifyPlaylist = JsonConvert.DeserializeObject<SpotifyPlaylist>(response.Content, new JsonSerializerSettings * { * MissingMemberHandling = MissingMemberHandling.Ignore * }); * } * } */ private SpotifyPlaylist CreateSpotifyPlaylist(string authorizationToken, string userId, string name) { var client = new RestClient(Constants.Spotify.WebApiBase + "users/" + userId + "/"); var request = new RestRequest("playlists", Method.POST); request.RequestFormat = DataFormat.Json; request.AddHeader("Authorization", "Bearer " + authorizationToken); request.AddHeader("Content-type", "application/json"); request.AddBody(new PlaylistRequestBody { name = name }); IRestResponse response = client.Execute(request); SpotifyPlaylist playlistResponse = null; if (response.IsSuccessful) { playlistResponse = JsonConvert.DeserializeObject <SpotifyPlaylist>(response.Content, new JsonSerializerSettings { MissingMemberHandling = MissingMemberHandling.Ignore }); } return(playlistResponse); }
public async Task <bool> PlayPlaylist(SpotifyPlaylist playlist, bool random = false) { try { JObject payload = new JObject(); payload["context_uri"] = playlist.Uri; JObject position = new JObject(); position["position"] = 0; payload["offset"] = position; if (random) { IEnumerable <SpotifySong> playlistSongs = await this.GetPlaylistSongs(playlist); if (playlistSongs != null && playlistSongs.Count() > 0) { position["position"] = RandomHelper.GenerateRandomNumber(playlistSongs.Count()); } } await this.PutAsync("me/player/shuffle?state=true", null); await Task.Delay(250); HttpResponseMessage playResponse = await this.PutAsync("me/player/play", this.CreateContentFromObject(payload)); await Task.Delay(250); await this.DisableRepeat(); return(playResponse.StatusCode == HttpStatusCode.NoContent); } catch (Exception ex) { Logger.Log(ex); } return(false); }
private async void AddPlaylistWithLink(object sender, RoutedEventArgs e) { const string linkPrefix = "https://open.spotify.com/playlist/"; const string uriPrefix = "spotify:playlist:"; var text = LinkTextBox.Text; var link = ""; if (text.Contains(linkPrefix)) { link = text.Substring(linkPrefix.Length); link = link.Substring(0, link.IndexOf("?", StringComparison.Ordinal)); } else if (text.Contains(uriPrefix)) { link = text.Substring(uriPrefix.Length); } var playlist = await spotify.GetPlaylistAsync(link); if (playlist.Id == null) { Utility.ShowErrorDialog("Bad link or URI", "Error"); LinkTextBox.Text = ""; return; } if (playlist.HasError()) { Utility.ShowErrorDialog(playlist.Error.Message, "Error"); return; } Playlist = new SpotifyPlaylist { Id = playlist.Id, Name = playlist.Name }; DialogResult = true; }
public static async Task <bool> SavePlaylistToFile(string filepath, SpotifyPlaylist playlist, List <PlaylistColumn> playlistColumns) { if (filepath == null || filepath == string.Empty) { return(false); } string playlistXml = await GetPlaylistAsXml(playlist, playlistColumns); if (playlistXml == null || playlistXml == string.Empty) { return(false); } using (FileStream oFileStream = File.Create(filepath)) { using (StreamWriter streamWriter = new StreamWriter(oFileStream)) { await streamWriter.WriteAsync(playlistXml); return(true); } } }
public async Task AddTracksToPlaylist(List <string> topTracks, string currentUser, SpotifyPlaylist playlist, string authToken) { var httpClient = new HttpClient { BaseAddress = new Uri("https://api.spotify.com/"), }; var urlFix = ""; foreach (var topTrack in topTracks) { if (topTrack == topTracks.First()) { urlFix += "uris="; } urlFix += $"{topTrack}"; if (topTrack == topTracks.Last()) { continue; } urlFix += ","; } httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authToken); HttpContent content = null; using (var response = await httpClient.PostAsync($"v1/users/{currentUser}/playlists/{playlist.id}/tracks?{urlFix}", content)) { response.EnsureSuccessStatusCode(); } // POST https://api.spotify.com/v1/users/{user_id}/playlists/{playlist_id}/tracks }
/// <summary> /// Seed database depuis une playlist Spotify /// </summary> /// <param name="database">DbContext de la base de données à seeder</param> /// <param name="playlist">Playlist à ajouter</param> /// <returns>Objet contenant les données à seeder</returns> public Seeder SeedFromPlaylist(WebzineDbContext database, SpotifyPlaylist playlist) { // Initialisation des listes List <Titre> titres = new List <Titre>(); List <Artiste> artistes = new List <Artiste>(); List <Style> styles = new List <Style> { new Style { LienStyle = new List <LienStyle>(), Libelle = "Spotify", IdStyle = 1 } }; // Récupération du style Spotify var spotifyStyle = styles.FirstOrDefault(s => s.Libelle == "Spotify"); // Pour chacune des musiques récupérées dans la Playlist (depuis l'API Spotify) playlist.Tracks.Items.ForEach(track => { // Initialisation des objets titres/artistes Titre ttr = new Titre(); Artiste art = new Artiste(); // Récupération des valeurs depuis l'objet Spotify ttr.Libelle = track.Track.Name; ttr.Album = track.Track.Album.Name; ttr.Chronique = "Chronique de base pour la musique " + ttr.Libelle; ttr.Commentaires = new List <Commentaire>(); ttr.DateCreation = DateTime.Now; ttr.DateSortie = DateTime.Parse(track.AddedAt); ttr.Duree = track.Track.Duration / 1000; // Si l'artiste existe déjà en base, récupération if (artistes.Exists(a => a.Nom == track.Track.Artists[0].Name)) { ttr.Artiste = artistes.FirstOrDefault(a => a.Nom == track.Track.Artists[0].Name); ttr.IdArtiste = ttr.Artiste.IdArtiste; } // Sinon création de l'artiste else { art.Nom = track.Track.Artists[0].Name; art.Biographie = "Biographie de " + art.Nom; art.Titres = new List <Titre>(); artistes.Add(art); ttr.IdArtiste = art.IdArtiste; ttr.Artiste = art; } // Si Spotify à bien renvoyé une jaquette pour ce titre if (track.Track.Album.Images != null && track.Track.Album.Images.Count > 0) { // Attribution ttr.UrlJaquette = track.Track.Album.Images[0].Url; } // Sinon, initialisé en string vide, les views afficheront une image par défaut (dans wwwroot) else { ttr.UrlJaquette = ""; } // Si jamais un Uri d'écoute est envoyé if (track.Track.SpotifyUri != null) { // Et est valide if (track.Track.SpotifyUri.Contains("spotify:track:")) { // Construction de l'URL d'écoute pour le Widget (Dans la page Titre) ttr.UrlEcoute = "https://open.spotify.com/embed/track/" + track.Track.SpotifyUri.Split("spotify:track:")[1]; } else { ttr.UrlEcoute = ""; } } else { ttr.UrlEcoute = ""; } ttr.NbLectures = 0; ttr.NbLikes = 0; // Ajout du titre dans la liste titres.Add(ttr); }); // Intègre les styles dans les musiques artistes.ForEach(artist => { artist.Titres = titres.Where(t => t.Artiste.Nom == artist.Nom).ToList(); }); // Ajout des listes en bases artistes.ForEach(a => database.Artistes.Add(a)); styles.ForEach(s => database.Styles.Add(s)); titres.ForEach(t => database.Titres.Add(t)); return(new Seeder() { Artistes = artistes, Titres = titres, Styles = styles }); }
public async Task RemoveSongFromPlaylist(SpotifyPlaylist playlist, SpotifySong song) { await this.RemoveSongsFromPlaylist(playlist, new List <SpotifySong>() { song }); }
public SpotifyPlaylist PlaylistExists(string name) { SpotifyPlaylist found = GetPlaylist(name); return(found); }
public async Task <ActionResult <SpotifyData> > GetExportAsync([FromQuery] SpotifyToken token) { var hasMore = false; var offset = 0; if (string.IsNullOrEmpty(token?.AccessToken)) { return(RedirectToAction(nameof(GetAuthorization))); } var data = new SpotifyData(); var user = await _spotifyService.GetMeAsync(token); if (string.IsNullOrEmpty(user.Id)) { return(RedirectToPage($"/Index", new { Message = "Invalid token, login!", Type = "warning" })); } data.UserId = user.Id; data.DisplayName = user.DisplayName; do { var playlists = await _spotifyService.GetPlaylistsAsync(token, offset); foreach (var playlist in playlists.Items) { if (!playlist.Owner.Id.Equals(user.Id)) { data.FollowPlaylists.Add(playlist.Uri); continue; } var playlistItem = new SpotifyPlaylist(playlist); var _continue = false; offset = 0; do { var playlistTracks = await _spotifyService.GetPlaylistsTracksAsync(token, playlist.Id, offset); if (playlistTracks.Total == 0) { _continue = true; break; } foreach (var playlistTrack in playlistTracks.Items) { if (playlistTrack.IsLocal) { continue; //ignore local } playlistItem.Tracks.Add(new SpotifyPlaylistTrack(playlistTrack.Track)); } hasMore = !string.IsNullOrEmpty(playlistTracks.Next); offset = playlistTracks.Offset + playlistTracks.Limit; } while (hasMore); if (_continue) { continue; } data.Playlists.Add(playlistItem); } hasMore = !string.IsNullOrEmpty(playlists.Next); offset = playlists.Offset + playlists.Limit; } while (hasMore); offset = 0; do { var tracks = await _spotifyService.GetTracksAsync(token, offset); foreach (var track in tracks.Items) { data.Tracks.Add(new SpotifyPlaylistTrack(track.Track)); } hasMore = !string.IsNullOrEmpty(tracks.Next); offset = tracks.Offset + tracks.Limit; } while (hasMore); return(data); }