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);
}
