public static void InsertTracks(SpotifyWebAPI spotify, List <string> tracksUri, string playlistId)
{
Console.WriteLine("Adding tracks to playlist...");
var position = 0;
var howMany = tracksUri.Count;
var iterationCounter = 1;
if (howMany > 100)
{
howMany = 100;
}
while (true)
{
if (howMany * iterationCounter > tracksUri.Count)
{
howMany = tracksUri.Count - 100 * iterationCounter + 100;
}
if (position >= tracksUri.Count)
{
break;
}
var addTracks = spotify.AddPlaylistTracks(playlistId, tracksUri.GetRange(position, howMany), position);
if (addTracks.HasError())
{
Console.WriteLine("Error while processing. Breaking.");
Console.WriteLine(addTracks.Error.Message);
break;
}
position += howMany;
iterationCounter++;
}
Console.WriteLine("Tracks added successfully.");
}
private ErrorResponse AddTracks(string playlistId, List <FullTrack> songs, bool?isLiked)
{
List <string> songUri = new List <string>();
ErrorResponse response = new ErrorResponse();
foreach (FullTrack track in songs)
{
songUri.Add(track.Uri);
}
foreach (List <string> listLimit in SplitList <string>(songUri, 99))
{
response = _spotify.AddPlaylistTracks(playlistId, listLimit);
}
//like added songs//
if (isLiked.GetValueOrDefault())
{
List <string> songIds = new List <string>();
foreach (FullTrack track in songs)
{
songIds.Add(track.Id);
}
foreach (List <string> listLimit in SplitList <string>(songIds, 99))
{
response = _spotify.SaveTracks(listLimit);
}
}
return(response);
}
private void addSongButton_Click(object sender, EventArgs e)
{
if (_spotifyWebAPI == null || _profile == null)
{
return;
}
if (searchView.SelectedItems.Count == 0)
{
return;
}
ListViewItem selectedSong = searchView.SelectedItems[0];
if (selectedSong == null)
{
return;
}
string songURL = selectedSong.Tag as string;
if (songURL == "")
{
return;
}
SimplePlaylist selectedPlaylist = (SimplePlaylist)playlistListbox.SelectedItem;
List <string> tracks = new List <string>();
for (int i = 0; i < addSongCount.Value; i++)
{
tracks.Add(songURL);
}
ErrorResponse error = _spotifyWebAPI.AddPlaylistTracks(_profile.Id, selectedPlaylist.Id, tracks);
}
public void AddPlaylistTracks(string userId, string playlistId, List <string> uriList)
{
for (var i = 0; i < uriList.Count; i = i + 100)
{
Extensions.WriteColoredConsole($"Adding {i} - {i + 100} of {uriList.Count}", ConsoleColor.White);
var items = uriList.Skip(i).Take(100).ToList();
WriteResponse(_spotify.AddPlaylistTracks(userId, playlistId, items));
}
}
static bool AddTracksToPlaylist(FullPlaylist playlist, List <string> uris)
{
ErrorResponse response = spotify.AddPlaylistTracks(playlist.Id, uris);
if (response.HasError())
{
return(false);
}
return(true);
}
public static void AddPlaylistTracks(List <string> trackUris, FullPlaylist spotifyPL, SpotifyWebAPI authObj)
{
var fullTrackUris = new List <string>();
int counter = 0;
foreach (string uri in trackUris)
{
fullTrackUris.Add("spotify:track:" + uri);
counter += 1;
if (counter >= 100)
{
authObj.AddPlaylistTracks(spotifyPL.Owner.Id, spotifyPL.Id, fullTrackUris);
counter = 0;
fullTrackUris.Clear();
}
}
authObj.AddPlaylistTracks(spotifyPL.Owner.Id, spotifyPL.Id, fullTrackUris);
}
public void AddTracksToPlaylist(SpotifyWebAPI api, List <SimpleTrack> tracks, string playlistId, Account user)
{
List <string> trackUris = new List <string>();
for (int i = 0; i < tracks.Count; i++)
{
trackUris.Add(tracks[i].Uri);
}
string id = (_spotifyWrapper.GetSpotifyProfile(GetSpotifyToken(user)) as SpotifyProfileModel).Id;
api.AddPlaylistTracks(id, playlistId, trackUris);
}
public void CreatePlaylistByCollection(string name, IEnumerable <BeatmapLittle> collection, out int numberOfSongs, bool mode = true)
{
var tracks = FindTracksByCollection(collection).Select(x => x.Uri).ToList();
var playlist = CreatePlaylist(name, mode);
var user = _spotify.GetPrivateProfile();
while (user.HasError())
{
Console.WriteLine("Error Status: " + user.Error.Status);
Console.WriteLine("Error Msg: CreatePlayListByCollection" + user.Error.Message);
Thread.Sleep(20);
user = _spotify.GetPrivateProfile();
}
_spotify.AddPlaylistTracks(user.Id, playlist.Id, tracks);
numberOfSongs = tracks.Count();
}
//saves the playlist to th users account and sends you back to the home page
public async Task <ActionResult> Save(string playlistName, bool isPublic = false)
{
string name = playlistName;
if (name == "")
{
name = ((IndexViewModel)TempData["ViewModel"]).title;
}
Token token = (Token)TempData["Token"];
AuthorizationCodeAuth auth = (AuthorizationCodeAuth)TempData["Auth"];
SpotifyWebAPI api = (SpotifyWebAPI)TempData["Api"];
Playlist currentPlaylist = (Playlist)TempData["Playlist"];
IndexViewModel viewModel = (IndexViewModel)TempData["ViewModel"];
viewModel.PlaylistURIs = (List <string>)TempData["PlaylistURIs"];
if (token.IsExpired())
{
Token newToken = await auth.RefreshToken(token.RefreshToken);
api.AccessToken = newToken.AccessToken;
api.TokenType = newToken.TokenType;
}
string userId = api.GetPrivateProfile().Id;
FullPlaylist playlist = api.CreatePlaylist(userId, name, isPublic);
ErrorResponse response = new ErrorResponse();
response = api.AddPlaylistTracks(playlist.Id, viewModel.PlaylistURIs);
TempData["FlashMessage"] = name + " was successfully created and saved to your Spotify account!";
TempData["isError"] = false;
//checks for error from laylist save and changes the flass message appropriately.
if (response.HasError())
{
TempData["FlashMessage"] = "Something went wrong while saving the playlist.";
TempData["isError"] = true;
}
return(RedirectToAction("Index", "Home"));
}
private void EmotionTemplate(string artistId_1, string genre_1, string trackId_1, string artistId_2, string genre_2)
{
SpotifyWebAPI spotify = new SpotifyWebAPI
{
UseAuth = true,
AccessToken = Session["SpotifyToken"].ToString(),
TokenType = "Bearer",
};
var recommendedSongs = spotify.GetRecommendations(
new List <string>()
{
artistId_1, artistId_2
},
new List <string>()
{
genre_1, genre_2
},
new List <string>()
{
trackId_1
},
null, null, null, 50, "BG");
var seededTracksUris = new List <string>();
recommendedSongs.Tracks.ForEach(item => seededTracksUris.Add(item.Uri));
var userId = spotify.GetPrivateProfile().Id;
var playlist = spotify.CreatePlaylist(userId, "Test");
spotify.FollowPlaylist(userId, playlist.Id);
spotify.AddPlaylistTracks(userId, playlist.Id, seededTracksUris);
this.Session["GeneratedPlaylist"] = playlist.Uri;
}
private async void OnShuffleButtonClick(string playlistId, ShuffleMode shuffleMode, View popup)
{
if (_state.Value != State.Waiting && _state.Value != State.Failed)
{
return;
}
_state.Value = State.LoadingTracks;
Task <Exception> task = Task <Exception> .Factory.StartNew(() =>
{
try
{
// get playlist
FullPlaylist playlist =
_api.GetPlaylist(playlistId, fields: "id,name,tracks.items(track.uri),tracks.total");
if (playlist.Tracks == null)
{
return(new Exception("Failed to get playlist"));
}
// get tracks
IList <FullTrack> tracks = Enumerable.Range(0, (int)Math.Ceiling(playlist.Tracks.Total / 100F))
.Select(i =>
_api.GetPlaylistTracks(playlist.Id, fields: "items.track(uri,artists.name)",
offset: i * 100))
.SelectMany(group => group.Items.Select(playlistTrack => playlistTrack.Track))
.ToList();
if (tracks.Count != playlist.Tracks.Total)
{
return(new Exception("Failed to get all tracks in playlist"));
}
// randomize track order
if (shuffleMode == ShuffleMode.Shuffle)
{
tracks.Shuffle();
}
else if (shuffleMode == ShuffleMode.Restrict)
{
// get value
EditText value = popup.FindViewById <EditText>(Resource.Id.restrict_value);
bool res = int.TryParse(value.Text, out int artistLimit);
// check value is valid
if (!res || artistLimit < 1)
{
throw new Exception("Restrict value is not a positive integer");
}
// save value
ISharedPreferencesEditor editor = GetSharedPreferences("SPOTIFY", 0).Edit();
editor.PutString("RESTRICT_VALUE", artistLimit.ToString());
editor.Commit();
tracks = tracks
.GroupBy(track => track.Artists[0].Name)
.SelectMany(artist => artist.ToList().Shuffle().Take(artistLimit))
.ToList()
.Shuffle();
}
// add tracks
string id = _api.GetPrivateProfile().Id;
// delete old playlists
foreach (SimplePlaylist p in _playlists.Where(p => p.Name == playlist.Name + " " + shuffleMode)
.ToList())
{
ErrorResponse error = _api.UnfollowPlaylist(id, p.Id);
if (error.HasError())
{
return(new Exception("Failed to delete old playlist"));
}
_playlists.Remove(p);
}
// create new playlist
_state.Value = State.AddingTracks;
FullPlaylist newPlaylist = _api.CreatePlaylist(id, playlist.Name + " " + shuffleMode, false);
if (newPlaylist.Id == null)
{
return(new Exception("Failed to create new playlist"));
}
_playlists.Add(new SimplePlaylist {
Id = newPlaylist.Id, Name = newPlaylist.Name
});
// add tracks
List <ErrorResponse> addResult = Enumerable.Range(0, (int)Math.Ceiling(tracks.Count / 100F)).Select(
i =>
_api.AddPlaylistTracks(newPlaylist.Id,
tracks.Skip(i * 100).Take(100).Select(track => track.Uri).ToList()))
.ToList();
if (addResult.Any(error => error.HasError()))
{
return(new Exception("Failed to add all tracks to playlist"));
}
return(null);
}
catch (Exception)
{
return(new Exception("Unknown error has occured"));
}
});
await task.ContinueWith(errorTask =>
{
if (errorTask.Result == null)
{
Log.Debug("ShuffleResult", "Shuffle succeeded");
_state.Value = State.Waiting;
}
else
{
Log.Debug("ShuffleResult", $"Shuffle failed: {errorTask.Result}");
_lastError = errorTask.Result.Message;
_state.Value = State.Failed;
}
});
}
