public String CreateNewPlaylist(String playlistName)
        {
            if (mProfile == null || mSpotify == null)
            {
                return("you need to connect to spotify before you can use this feature");
            }
            if (playlists == null)
            {
                playlists = mSpotify.GetUserPlaylists(mProfile.Id).Items;
            }
            if (playlists.Find(x => x.Name == playlistName) != null)
            {
                return($"A playlist named {playlistName} already exists");
            }

            Models.FullPlaylist newPlaylist = mSpotify.CreatePlaylist(mProfile.Id, playlistName, false);

            Models.SimplePlaylist newSimplePlaylist = new Models.SimplePlaylist();
            newSimplePlaylist.Name  = newPlaylist.Name;
            newSimplePlaylist.Id    = newPlaylist.Id;
            newSimplePlaylist.Owner = newPlaylist.Owner;
            playlists.Add(newSimplePlaylist);

            return($"{playlistName} was successfully created");
        }
        public String AddSongToPlayList(String playlistName, String songName, String artist)
        {
            if (mProfile == null || mSpotify == null)
            {
                return("you need to connect to spotify before you can use this feature");
            }

            if (playlists == null)
            {
                playlists = mSpotify.GetUserPlaylists(mProfile.Id).Items;
            }

            Models.SimplePlaylist playlist = playlists.Find(x => x.Name == playlistName);

            if (playlist == null)
            {
                return($"could not find playlist {playlistName}");
            }

            Models.SearchItem search = mSpotify.SearchItems(songName, Enums.SearchType.Track);

            if (search.Tracks == null || search.Tracks.Items.Count == 0)
            {
                return($"could not find song {songName}");
            }

            Models.FullTrack songData = search.Tracks.Items.Find(x => String.Equals(x.Artists[0].Name, artist, StringComparison.OrdinalIgnoreCase));

            if (songData == null)
            {
                return($"could not find song {songName} by {artist}");
            }

            Models.ErrorResponse error = mSpotify.AddPlaylistTrack(mProfile.Id, playlist.Id, songData.Uri);

            if (error.Error != null)
            {
                return(error.Error.Message);
            }

            return($"{songName} by {artist} was sucessfully added to {playlistName}");
        }
        private void getCommentsForPlaylistTracks(SimplePlaylist playlist)
        {
            foreach (var track in playlist.Tracks.PlaylistTracks)
            {

                // needed for comments in database
                track.Track.PlaylistId = playlist.Id;

                var comments = Comments.Where(e => e.TrackId == track.Track.Id && e.PlaylistId == playlist.Id);
                if (!comments.Any())
                    continue;

                //comments.OrderBy(e => e.Timestamp;
                foreach (var comment in Comments)
                {
                    comment.IsOwnComment = comment.Username == PrivateProfile.Id;
                }

                track.Track.Comments = new List<Comments>(comments);
            }
        }
        private void getTracksForPlaylist(SimplePlaylist playlist)
        {
            IsLoading = true;
            var tracks = _spotifyWeb.GetPlaylistTracks(playlist.Owner.Id, playlist.Id, string.Empty, Statics.PLAYLIST_TRACK_LIMIT);

            playlist.Tracks.PlaylistTracks = tracks.Items;

            getCommentsForPlaylistTracks(playlist);

            IsLoading = false;
        }
 public SpotifyPlaylist(SimplePlaylist oSpotifySimplePlaylist, Dictionary<int, SpotifyTrack> oTracks)
     : base(oSpotifySimplePlaylist.Id, oSpotifySimplePlaylist.Name)
 {
     this._Tracks = oTracks;
 }
        private void getCommentsForPlaylistTracks(SimplePlaylist playlist)
        {
            foreach (var track in playlist.Tracks.PlaylistTracks)
            {

                // needed for comments in database
                track.Track.PlaylistId = playlist.Id;

                var comments = Comments.Where(e => e.TrackId == track.Track.Id && e.PlaylistId == playlist.Id);
                if (!comments.Any())
                    continue;

                comments.OrderBy(e => e.Order);
                track.Track.Comments = new List<Comments>(comments);
            }
        }
        private static Dictionary<int, SpotifyTrack> GetTracksForPlaylist(SpotifyWebAPI oWebCLient, SimplePlaylist oSimplePlaylist, SpotifyUser oSpotifyUser)
        {
            Dictionary<int, SpotifyTrack> oTracks = new Dictionary<int, SpotifyTrack>();
            Paging<PlaylistTrack> oPagingPlaylistTracks = oWebCLient.GetPlaylistTracks(oSimplePlaylist.Owner.Id, oSimplePlaylist.Id, market:"");
            int iPos = 0;
            foreach (PlaylistTrack oPlaylistTrack in oPagingPlaylistTracks.Items)
            {
                List<SpotifyArtist> oArtists = new List<SpotifyArtist>();
                oArtists.AddRange(GetArtistsForTrack(oPlaylistTrack));
                if (oPlaylistTrack.Track.Id == null)
                {
                    if (oPlaylistTrack.Track.Name != null && oPlaylistTrack.Track.Type != null)
                    {//Issues with some tracks having null id properties and the only way to deal with that is to try to hash an id myself
                        oPlaylistTrack.Track.Id = HashSlingingSlasher.HashString(oSimplePlaylist.Name + oSimplePlaylist.Type);
                    }

                }
                oTracks.Add(iPos, new SpotifyTrack(oPlaylistTrack, oArtists));
                iPos++;
            }
            while (oPagingPlaylistTracks.Next != null)
            {
                oPagingPlaylistTracks = oWebCLient.DownloadData<Paging<PlaylistTrack>>(oPagingPlaylistTracks.Next);
                foreach (PlaylistTrack oPlaylistTrack in oPagingPlaylistTracks.Items)
                {
                    List<SpotifyArtist> oArtists = new List<SpotifyArtist>();
                    oArtists.AddRange(GetArtistsForTrack(oPlaylistTrack));
                    if (oPlaylistTrack.Track.Id == null)
                    {
                        if (oPlaylistTrack.Track.Name != null && oPlaylistTrack.Track.Type != null)
                        {//Issues with some tracks having null id properties and the only way to deal with that is to try to hash an id myself
                            oPlaylistTrack.Track.Id = HashSlingingSlasher.HashString(oSimplePlaylist.Name + oSimplePlaylist.Type);
                        }

                    }
                    oTracks.Add(iPos, new SpotifyTrack(oPlaylistTrack, oArtists));
                    iPos++;
                }
            }

            return oTracks;
        }