From f182b5ea992e769ae5c29983285466f7b98799b4 Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 14:36:08 +0100
Subject: [PATCH 1/9] Added Async Methods for
 Search/Albums/Artists/Browse/Follow/Library

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 539 +++++++++++++++++++++++++++-----
 1 file changed, 453 insertions(+), 86 deletions(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index 2960d665..900bff58 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -88,13 +88,21 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Paging<SimpleTrack> GetAlbumTracks(String id, int limit = 20, int offset = 0, String market = "")
         {
-            limit = Math.Min(limit, 50);
-            StringBuilder builder = new StringBuilder(APIBase + "/albums/" + id + "/tracks");
-            builder.Append("?limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(market))
-                builder.Append("&market=" + market);
-            return DownloadData<Paging<SimpleTrack>>(builder.ToString());
+            return DownloadData<Paging<SimpleTrack>>(_builder.SearchItems(id, limit, offset, market));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information about an album’s tracks asynchronously. Optional parameters can be used to limit the number of
+        ///     tracks returned.
+        /// </summary>
+        /// <param name="id">The Spotify ID for the album.</param>
+        /// <param name="limit">The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.</param>
+        /// <param name="offset">The index of the first track to return. Default: 0 (the first object).</param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        public Task<Paging<SimpleTrack>> GetAlbumTracksAsync(String id, int limit = 20, int offset = 0, String market = "")
+        {
+            return DownloadDataAsync<Paging<SimpleTrack>>(_builder.SearchItems(id, limit, offset, market));
         }
 
         /// <summary>
@@ -106,8 +114,21 @@ namespace SpotifyAPI.Web
         public FullAlbum GetAlbum(String id, String market = "")
         {
             if (String.IsNullOrEmpty(market))
-                return DownloadData<FullAlbum>(APIBase + "/albums/" + id);
-            return DownloadData<FullAlbum>(APIBase + "/albums/" + id + "?market=" + market);
+                return DownloadData<FullAlbum>(_builder.SearchItems(id));
+            return DownloadData<FullAlbum>(_builder.SearchItems(id, market));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information for a single album asynchronously.
+        /// </summary>
+        /// <param name="id">The Spotify ID for the album.</param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        public Task<FullAlbum> GetAlbumAsync(String id, String market = "")
+        {
+            if (String.IsNullOrEmpty(market))
+                return DownloadDataAsync<FullAlbum>(_builder.SearchItems(id));
+            return DownloadDataAsync<FullAlbum>(_builder.SearchItems(id, market));
         }
 
         /// <summary>
@@ -119,8 +140,21 @@ namespace SpotifyAPI.Web
         public SeveralAlbums GetSeveralAlbums(List<String> ids, String market = "")
         {
             if (String.IsNullOrEmpty(market))
-                return DownloadData<SeveralAlbums>(APIBase + "/albums?ids=" + string.Join(",", ids.Take(20)));
-            return DownloadData<SeveralAlbums>(APIBase + "/albums?market=" + market + "&ids=" + string.Join(",", ids.Take(20)));
+                return DownloadData<SeveralAlbums>(_builder.SearchItems(ids));
+            return DownloadData<SeveralAlbums>(_builder.SearchItems(ids, market));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information for multiple albums identified by their Spotify IDs asynchrously.
+        /// </summary>
+        /// <param name="ids">A list of the Spotify IDs for the albums. Maximum: 20 IDs.</param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        public Task<SeveralAlbums> GetSeveralAlbumsAsync(List<String> ids, String market = "")
+        {
+            if (String.IsNullOrEmpty(market))
+                return DownloadDataAsync<SeveralAlbums>(_builder.SearchItems(ids));
+            return DownloadDataAsync<SeveralAlbums>(_builder.SearchItems(ids, market));
         }
 
         #endregion Albums
@@ -134,7 +168,17 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public FullArtist GetArtist(String id)
         {
-            return DownloadData<FullArtist>(APIBase + "/artists/" + id);
+            return DownloadData<FullArtist>(_builder.SearchItems(id));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information for a single artist identified by their unique Spotify ID asynchronously.
+        /// </summary>
+        /// <param name="id">The Spotify ID for the artist.</param>
+        /// <returns></returns>
+        public Task<FullArtist> GetArtistAsync(String id)
+        {
+            return DownloadDataAsync<FullArtist>(_builder.SearchItems(id));
         }
 
         /// <summary>
@@ -145,7 +189,18 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralArtists GetRelatedArtists(String id)
         {
-            return DownloadData<SeveralArtists>(APIBase + "/artists/" + id + "/related-artists");
+            return DownloadData<SeveralArtists>(_builder.SearchItems(id));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information about artists similar to a given artist asynchronously. Similarity is based on analysis of the
+        ///     Spotify community’s listening history.
+        /// </summary>
+        /// <param name="id">The Spotify ID for the artist.</param>
+        /// <returns></returns>
+        public Task<SeveralArtists> GetRelatedArtistsAsync(String id)
+        {
+            return DownloadDataAsync<SeveralArtists>(_builder.SearchItems(id));
         }
 
         /// <summary>
@@ -156,7 +211,18 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralTracks GetArtistsTopTracks(String id, String country)
         {
-            return DownloadData<SeveralTracks>(APIBase + "/artists/" + id + "/top-tracks?country=" + country);
+            return DownloadData<SeveralTracks>(_builder.SearchItems(id, country));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information about an artist’s top tracks by country asynchronously.
+        /// </summary>
+        /// <param name="id">The Spotify ID for the artist.</param>
+        /// <param name="country">The country: an ISO 3166-1 alpha-2 country code.</param>
+        /// <returns></returns>
+        public Task<SeveralTracks> GetArtistsTopTracksAsync(String id, String country)
+        {
+            return DownloadDataAsync<SeveralTracks>(_builder.SearchItems(id, country));
         }
 
         /// <summary>
@@ -177,14 +243,28 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Paging<SimpleAlbum> GetArtistsAlbums(String id, AlbumType type = AlbumType.All, int limit = 20, int offset = 0, String market = "")
         {
-            limit = Math.Min(limit, 50);
-            StringBuilder builder = new StringBuilder(APIBase + "/artists/" + id + "/albums");
-            builder.Append("?type=" + type.GetStringAttribute(","));
-            builder.Append("&limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(market))
-                builder.Append("&market=" + market);
-            return DownloadData<Paging<SimpleAlbum>>(builder.ToString());
+            return DownloadData<Paging<SimpleAlbum>>(_builder.SearchItems(id, type, limit, offset, market));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information about an artist’s albums asynchronously. Optional parameters can be specified in the query string
+        ///     to filter and sort the response.
+        /// </summary>
+        /// <param name="id">The Spotify ID for the artist.</param>
+        /// <param name="type">
+        ///     A list of keywords that will be used to filter the response. If not supplied, all album types will
+        ///     be returned
+        /// </param>
+        /// <param name="limit">The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.</param>
+        /// <param name="offset">The index of the first album to return. Default: 0</param>
+        /// <param name="market">
+        ///     An ISO 3166-1 alpha-2 country code. Supply this parameter to limit the response to one particular
+        ///     geographical market
+        /// </param>
+        /// <returns></returns>
+        public Task<Paging<SimpleAlbum>> GetArtistsAlbumsAsync(String id, AlbumType type = AlbumType.All, int limit = 20, int offset = 0, String market = "")
+        {
+            return DownloadDataAsync<Paging<SimpleAlbum>>(_builder.SearchItems(id, type, limit, offset, market));
         }
 
         /// <summary>
@@ -194,7 +274,17 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralArtists GetSeveralArtists(List<String> ids)
         {
-            return DownloadData<SeveralArtists>(APIBase + "/artists?ids=" + string.Join(",", ids.Take(50)));
+            return DownloadData<SeveralArtists>(_builder.SearchItems(ids));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information for several artists based on their Spotify IDs asynchronously.
+        /// </summary>
+        /// <param name="ids">A list of the Spotify IDs for the artists. Maximum: 50 IDs.</param>
+        /// <returns></returns>
+        public Task<SeveralArtists> GetSeveralArtistsAsync(List<String> ids)
+        {
+            return DownloadDataAsync<SeveralArtists>(_builder.SearchItems(ids));
         }
 
         #endregion Artists
@@ -217,17 +307,26 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetFeaturedPlaylists");
-            limit = Math.Max(limit, 50);
-            StringBuilder builder = new StringBuilder(APIBase + "/browse/featured-playlists");
-            builder.Append("?limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(locale))
-                builder.Append("&locale=" + locale);
-            if (!String.IsNullOrEmpty(country))
-                builder.Append("&country=" + country);
-            if (timestamp != default(DateTime))
-                builder.Append("&timestamp=" + timestamp.ToString("yyyy-MM-ddTHH:mm:ss"));
-            return DownloadData<FeaturedPlaylists>(builder.ToString());
+            return DownloadData<FeaturedPlaylists>(_builder.SearchItems(locale, country, timestamp, limit, offset));
+        }
+
+        /// <summary>
+        ///     Get a list of Spotify featured playlists asynchronously (shown, for example, on a Spotify player’s “Browse” tab).
+        /// </summary>
+        /// <param name="locale">
+        ///     The desired language, consisting of a lowercase ISO 639 language code and an uppercase ISO 3166-1
+        ///     alpha-2 country code, joined by an underscore.
+        /// </param>
+        /// <param name="country">A country: an ISO 3166-1 alpha-2 country code.</param>
+        /// <param name="timestamp">A timestamp in ISO 8601 format</param>
+        /// <param name="limit">The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.</param>
+        /// <param name="offset">The index of the first item to return. Default: 0</param>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<FeaturedPlaylists> GetFeaturedPlaylistsAsync(String locale = "", String country = "", DateTime timestamp = default(DateTime), int limit = 20, int offset = 0)
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetFeaturedPlaylists");
+            return DownloadDataAsync<FeaturedPlaylists>(_builder.SearchItems(locale, country, timestamp, limit, offset));
         }
 
         /// <summary>
@@ -242,13 +341,22 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetNewAlbumReleases");
-            limit = Math.Max(limit, 50);
-            StringBuilder builder = new StringBuilder(APIBase + "/browse/new-releases");
-            builder.Append("?limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(country))
-                builder.Append("&country=" + country);
-            return DownloadData<NewAlbumReleases>(builder.ToString());
+            return DownloadData<NewAlbumReleases>(_builder.SearchItems(country, limit, offset));
+        }
+
+        /// <summary>
+        ///     Get a list of new album releases featured in Spotify asynchronously (shown, for example, on a Spotify player’s “Browse” tab).
+        /// </summary>
+        /// <param name="country">A country: an ISO 3166-1 alpha-2 country code.</param>
+        /// <param name="limit">The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.</param>
+        /// <param name="offset">The index of the first item to return. Default: 0</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<NewAlbumReleases> GetNewAlbumReleasesAsync(String country = "", int limit = 20, int offset = 0)
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetNewAlbumReleases");
+            return DownloadDataAsync<NewAlbumReleases>(_builder.SearchItems(country, limit, offset));
         }
 
         /// <summary>
@@ -270,15 +378,29 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetCategories");
-            limit = Math.Min(50, limit);
-            StringBuilder builder = new StringBuilder(APIBase + "/browse/categories");
-            builder.Append("?limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(country))
-                builder.Append("&country=" + country);
-            if (!String.IsNullOrEmpty(locale))
-                builder.Append("&locale=" + locale);
-            return DownloadData<CategoryList>(builder.ToString());
+            return DownloadData<CategoryList>(_builder.SearchItems(country, locale, limit, offset));
+        }
+
+        /// <summary>
+        ///     Get a list of categories used to tag items in Spotify asynchronously (on, for example, the Spotify player’s “Browse” tab).
+        /// </summary>
+        /// <param name="country">
+        ///     A country: an ISO 3166-1 alpha-2 country code. Provide this parameter if you want to narrow the
+        ///     list of returned categories to those relevant to a particular country
+        /// </param>
+        /// <param name="locale">
+        ///     The desired language, consisting of an ISO 639 language code and an ISO 3166-1 alpha-2 country
+        ///     code, joined by an underscore
+        /// </param>
+        /// <param name="limit">The maximum number of categories to return. Default: 20. Minimum: 1. Maximum: 50. </param>
+        /// <param name="offset">The index of the first item to return. Default: 0 (the first object).</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<CategoryList> GetCategoriesAsync(String country = "", String locale = "", int limit = 20, int offset = 0)
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetCategories");
+            return DownloadDataAsync<CategoryList>(_builder.SearchItems(country, locale, limit, offset));
         }
 
         /// <summary>
@@ -297,12 +419,26 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public Category GetCategory(String categoryId, String country = "", String locale = "")
         {
-            StringBuilder builder = new StringBuilder(APIBase + "/browse/categories/" + categoryId);
-            if (!String.IsNullOrEmpty(country))
-                builder.Append("?country=" + country);
-            if (!String.IsNullOrEmpty(locale))
-                builder.Append((country == "" ? "?locale=" : "&locale=") + locale);
-            return DownloadData<Category>(builder.ToString());
+            return DownloadData<Category>(_builder.SearchItems(categoryId, country, locale));
+        }
+
+        /// <summary>
+        ///     Get a single category used to tag items in Spotify asynchronously (on, for example, the Spotify player’s “Browse” tab).
+        /// </summary>
+        /// <param name="categoryId">The Spotify category ID for the category.</param>
+        /// <param name="country">
+        ///     A country: an ISO 3166-1 alpha-2 country code. Provide this parameter to ensure that the category
+        ///     exists for a particular country.
+        /// </param>
+        /// <param name="locale">
+        ///     The desired language, consisting of an ISO 639 language code and an ISO 3166-1 alpha-2 country
+        ///     code, joined by an underscore
+        /// </param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<Category> GetCategoryAsync(String categoryId, String country = "", String locale = "")
+        {
+            return DownloadDataAsync<Category>(_builder.SearchItems(categoryId, country, locale));
         }
 
         /// <summary>
@@ -316,13 +452,21 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public CategoryPlaylist GetCategoryPlaylists(String categoryId, String country = "", int limit = 20, int offset = 0)
         {
-            limit = Math.Min(50, limit);
-            StringBuilder builder = new StringBuilder(APIBase + "/browse/categories/" + categoryId + "/playlists");
-            builder.Append("?limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(country))
-                builder.Append("&country=" + country);
-            return DownloadData<CategoryPlaylist>(builder.ToString());
+            return DownloadData<CategoryPlaylist>(_builder.SearchItems(categoryId, country, limit, offset));
+        }
+
+        /// <summary>
+        ///     Get a list of Spotify playlists tagged with a particular category asynchronously.
+        /// </summary>
+        /// <param name="categoryId">The Spotify category ID for the category.</param>
+        /// <param name="country">A country: an ISO 3166-1 alpha-2 country code.</param>
+        /// <param name="limit">The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50.</param>
+        /// <param name="offset">The index of the first item to return. Default: 0</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<CategoryPlaylist> GetCategoryPlaylistsAsync(String categoryId, String country = "", int limit = 20, int offset = 0)
+        {
+            return DownloadDataAsync<CategoryPlaylist>(_builder.SearchItems(categoryId, country, limit, offset));
         }
 
         #endregion Browse
@@ -332,21 +476,31 @@ namespace SpotifyAPI.Web
         /// <summary>
         ///     Get the current user’s followed artists.
         /// </summary>
+        /// <param name="followType">The ID type: currently only artist is supported. </param>
         /// <param name="limit">The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50. </param>
         /// <param name="after">The last artist ID retrieved from the previous request.</param>
         /// <returns></returns>
         /// <remarks>AUTH NEEDED</remarks>
-        public FollowedArtists GetFollowedArtists(int limit = 20, String after = "")
+        public FollowedArtists GetFollowedArtists(FollowType followType, int limit = 20, String after = "")
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetFollowedArtists");
-            limit = Math.Max(limit, 50);
-            const FollowType followType = FollowType.Artist; //currently only artist is supported.
-            StringBuilder builder = new StringBuilder(APIBase + "/me/following?type=" + followType.GetStringAttribute(""));
-            builder.Append("&limit=" + limit);
-            if (!String.IsNullOrEmpty(after))
-                builder.Append("&after=" + after);
-            return DownloadData<FollowedArtists>(builder.ToString());
+            return DownloadData<FollowedArtists>(_builder.SearchItems(followType, limit, after));
+        }
+
+        /// <summary>
+        ///     Get the current user’s followed artists asynchronously.
+        /// </summary>
+        /// <param name="followType">The ID type: currently only artist is supported. </param>
+        /// <param name="limit">The maximum number of items to return. Default: 20. Minimum: 1. Maximum: 50. </param>
+        /// <param name="after">The last artist ID retrieved from the previous request.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<FollowedArtists> GetFollowedArtistsAsync(FollowType followType, int limit = 20, String after = "")
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetFollowedArtists");
+            return DownloadDataAsync<FollowedArtists>(_builder.SearchItems(followType, limit, after));
         }
 
         /// <summary>
@@ -362,7 +516,25 @@ namespace SpotifyAPI.Web
             {
                 {"ids", new JArray(ids)}
             };
-            return UploadData<ErrorResponse>(APIBase + "/me/following?type=" + followType.GetStringAttribute(""), ob.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.SearchItems(followType, ids), ob.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+        }
+
+        /// <summary>
+        ///     Add the current user as a follower of one or more artists or other Spotify users asynchronously.
+        /// </summary>
+        /// <param name="followType">The ID type: either artist or user.</param>
+        /// <param name="ids">A list of the artist or the user Spotify IDs</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> FollowAsync(FollowType followType, List<String> ids)
+        {
+            JObject ob = new JObject
+            {
+                {"ids", new JArray(ids)}
+            };
+            return
+                UploadDataAsync<ErrorResponse>(_builder.SearchItems(followType, ids),
+                    ob.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>
@@ -377,6 +549,18 @@ namespace SpotifyAPI.Web
             return Follow(followType, new List<string> { id });
         }
 
+        /// <summary>
+        ///     Add the current user as a follower of one or more artists or other Spotify users asynchronously.
+        /// </summary>
+        /// <param name="followType">The ID type: either artist or user.</param>
+        /// <param name="id">Artists or the Users Spotify ID</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> FollowAsync(FollowType followType, String id)
+        {
+            return FollowAsync(followType, new List<string> { id });
+        }
+
         /// <summary>
         ///     Remove the current user as a follower of one or more artists or other Spotify users.
         /// </summary>
@@ -390,7 +574,23 @@ namespace SpotifyAPI.Web
             {
                 {"ids", new JArray(ids)}
             };
-            return UploadData<ErrorResponse>(APIBase + "/me/following?type=" + followType.GetStringAttribute(""), ob.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.SearchItems(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+        }
+
+        /// <summary>
+        ///     Remove the current user as a follower of one or more artists or other Spotify users asynchronously.
+        /// </summary>
+        /// <param name="followType">The ID type: either artist or user.</param>
+        /// <param name="ids">A list of the artist or the user Spotify IDs</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> UnfollowAsync(FollowType followType, List<String> ids)
+        {
+            JObject ob = new JObject
+            {
+                {"ids", new JArray(ids)}
+            };
+            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>
@@ -405,6 +605,18 @@ namespace SpotifyAPI.Web
             return Unfollow(followType, new List<string> { id });
         }
 
+        /// <summary>
+        ///     Remove the current user as a follower of one or more artists or other Spotify users asynchronously.
+        /// </summary>
+        /// <param name="followType">The ID type: either artist or user.</param>
+        /// <param name="id">Artists or the Users Spotify ID</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> UnfollowAsync(FollowType followType, String id)
+        {
+            return UnfollowAsync(followType, new List<string> { id });
+        }
+
         /// <summary>
         ///     Check to see if the current user is following one or more artists or other Spotify users.
         /// </summary>
@@ -416,12 +628,29 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowing");
-            JToken res = DownloadData<JToken>(APIBase + "/me/following/contains?type=" + followType.GetStringAttribute("") + "&ids=" + string.Join(",", ids));
+            JToken res = DownloadData<JToken>(_builder.SearchItems(followType, ids));
             if (res is JArray)
                 return new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null };
             return new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() };
         }
 
+        /// <summary>
+        ///     Check to see if the current user is following one or more artists or other Spotify users asynchronously.
+        /// </summary>
+        /// <param name="followType">The ID type: either artist or user.</param>
+        /// <param name="ids">A list of the artist or the user Spotify IDs to check</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ListResponse<Boolean>> IsFollowingAsync(FollowType followType, List<String> ids)
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for IsFollowing");
+            JToken res = DownloadDataAsync<JToken>(_builder.SearchItems(followType, ids));
+            if (res is JArray) //todo expression is always false
+                return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
+            return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });
+        }
+
         /// <summary>
         ///     Check to see if the current user is following one artist or another Spotify user.
         /// </summary>
@@ -434,6 +663,18 @@ namespace SpotifyAPI.Web
             return IsFollowing(followType, new List<string> { id });
         }
 
+        /// <summary>
+        ///     Check to see if the current user is following one artist or another Spotify user asynchronously.
+        /// </summary>
+        /// <param name="followType">The ID type: either artist or user.</param>
+        /// <param name="id">Artists or the Users Spotify ID</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ListResponse<Boolean>> IsFollowingAsync(FollowType followType, String id)
+        {
+            return IsFollowingAsync(followType, new List<string> { id });
+        }
+
         /// <summary>
         ///     Add the current user as a follower of a playlist.
         /// </summary>
@@ -454,7 +695,30 @@ namespace SpotifyAPI.Web
             {
                 {"public", showPublic}
             };
-            return UploadData<ErrorResponse>(APIBase + "/users/" + ownerId + "/playlists/" + playlistId + "/followers", body.ToString(Formatting.None), "PUT");
+            return UploadData<ErrorResponse>(_builder.SearchItems(ownerId, playlistId, showPublic), body.ToString(Formatting.None), "PUT");
+        }
+
+        /// <summary>
+        ///     Add the current user as a follower of a playlist asynchronously.
+        /// </summary>
+        /// <param name="ownerId">The Spotify user ID of the person who owns the playlist.</param>
+        /// <param name="playlistId">
+        ///     The Spotify ID of the playlist. Any playlist can be followed, regardless of its public/private
+        ///     status, as long as you know its playlist ID.
+        /// </param>
+        /// <param name="showPublic">
+        ///     If true the playlist will be included in user's public playlists, if false it will remain
+        ///     private.
+        /// </param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> FollowPlaylistAsync(String ownerId, String playlistId, bool showPublic = true)
+        {
+            JObject body = new JObject
+            {
+                {"public", showPublic}
+            };
+            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(ownerId, playlistId, showPublic), body.ToString(Formatting.None), "PUT");
         }
 
         /// <summary>
@@ -466,7 +730,19 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public ErrorResponse UnfollowPlaylist(String ownerId, String playlistId)
         {
-            return UploadData<ErrorResponse>(APIBase + "/users/" + ownerId + "/playlists/" + playlistId + "/followers", "", "DELETE");
+            return UploadData<ErrorResponse>(_builder.SearchItems(ownerId, playlistId), "", "DELETE");
+        }
+
+        /// <summary>
+        ///     Remove the current user as a follower of a playlist asynchronously.
+        /// </summary>
+        /// <param name="ownerId">The Spotify user ID of the person who owns the playlist.</param>
+        /// <param name="playlistId">The Spotify ID of the playlist that is to be no longer followed.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> UnfollowPlaylistAsync(String ownerId, String playlistId)
+        {
+            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(ownerId, playlistId), "", "DELETE");
         }
 
         /// <summary>
@@ -481,12 +757,30 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowingPlaylist");
-            JToken res = DownloadData<JToken>(APIBase + "/users/" + ownerId + "/playlists/" + playlistId + "/followers/contains?ids=" + string.Join(",", ids));
+            JToken res = DownloadData<JToken>(_builder.SearchItems(ownerId, playlistId, ids));
             if (res is JArray)
                 return new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null };
             return new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() };
         }
 
+        /// <summary>
+        ///     Check to see if one or more Spotify users are following a specified playlist asynchronously.
+        /// </summary>
+        /// <param name="ownerId">The Spotify user ID of the person who owns the playlist.</param>
+        /// <param name="playlistId">The Spotify ID of the playlist.</param>
+        /// <param name="ids">A list of Spotify User IDs</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ListResponse<Boolean>> IsFollowingPlaylistAsync(String ownerId, String playlistId, List<String> ids)
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for IsFollowingPlaylist");
+            JToken res = DownloadDataAsync<JToken>(_builder.SearchItems(ownerId, playlistId, ids));
+            if (res is JArray) //todo expression is always false
+                return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
+            return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });
+        }
+
         /// <summary>
         ///     Check to see if one or more Spotify users are following a specified playlist.
         /// </summary>
@@ -500,6 +794,19 @@ namespace SpotifyAPI.Web
             return IsFollowingPlaylist(ownerId, playlistId, new List<string> { id });
         }
 
+        /// <summary>
+        ///     Check to see if one or more Spotify users are following a specified playlist asynchronously.
+        /// </summary>
+        /// <param name="ownerId">The Spotify user ID of the person who owns the playlist.</param>
+        /// <param name="playlistId">The Spotify ID of the playlist.</param>
+        /// <param name="id">A Spotify User ID</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ListResponse<Boolean>> IsFollowingPlaylistAsync(String ownerId, String playlistId, String id)
+        {
+            return IsFollowingPlaylistAsync(ownerId, playlistId, new List<string> { id });
+        }
+
         #endregion Follow
 
         #region Library
@@ -513,7 +820,19 @@ namespace SpotifyAPI.Web
         public ErrorResponse SaveTracks(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadData<ErrorResponse>(APIBase + "/me/tracks/", array.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+        }
+
+        /// <summary>
+        ///     Save one or more tracks to the current user’s “Your Music” library asynchronously.
+        /// </summary>
+        /// <param name="ids">A list of the Spotify IDs</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> SaveTracksAsync(List<String> ids)
+        {
+            JArray array = new JArray(ids);
+            return UploadDataAsync<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>
@@ -527,6 +846,17 @@ namespace SpotifyAPI.Web
             return SaveTracks(new List<string> { id });
         }
 
+        /// <summary>
+        ///     Save one track to the current user’s “Your Music” library asynchronously.
+        /// </summary>
+        /// <param name="id">A Spotify ID</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> SaveTrackAsync(String id)
+        {
+            return SaveTracksAsync(new List<string> { id });
+        }
+
         /// <summary>
         ///     Get a list of the songs saved in the current Spotify user’s “Your Music” library.
         /// </summary>
@@ -539,13 +869,22 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetSavedTracks");
-            limit = Math.Min(limit, 50);
-            StringBuilder builder = new StringBuilder(APIBase + "/me/tracks");
-            builder.Append("?limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(market))
-                builder.Append("&market=" + market);
-            return DownloadData<Paging<SavedTrack>>(builder.ToString());
+            return DownloadData<Paging<SavedTrack>>(_builder.SearchItems(limit, offset, market));
+        }
+
+        /// <summary>
+        ///     Get a list of the songs saved in the current Spotify user’s “Your Music” library asynchronously.
+        /// </summary>
+        /// <param name="limit">The maximum number of objects to return. Default: 20. Minimum: 1. Maximum: 50.</param>
+        /// <param name="offset">The index of the first object to return. Default: 0 (i.e., the first object)</param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<Paging<SavedTrack>> GetSavedTracksAsync(int limit = 20, int offset = 0, String market = "")
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetSavedTracks");
+            return DownloadDataAsync<Paging<SavedTrack>>(_builder.SearchItems(limit, offset, market));
         }
 
         /// <summary>
@@ -557,7 +896,19 @@ namespace SpotifyAPI.Web
         public ErrorResponse RemoveSavedTracks(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadData<ErrorResponse>(APIBase + "/me/tracks/", array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+        }
+
+        /// <summary>
+        ///     Remove one or more tracks from the current user’s “Your Music” library asynchronously.
+        /// </summary>
+        /// <param name="ids">A list of the Spotify IDs.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> RemoveSavedTracksAsync(List<String> ids)
+        {
+            JArray array = new JArray(ids);
+            return UploadDataAsync<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>
@@ -576,6 +927,22 @@ namespace SpotifyAPI.Web
             return new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() };
         }
 
+        /// <summary>
+        ///     Check if one or more tracks is already saved in the current Spotify user’s “Your Music” library asynchronously.
+        /// </summary>
+        /// <param name="ids">A list of the Spotify IDs.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ListResponse<Boolean>> CheckSavedTracksAsync(List<String> ids)
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for CheckSavedTracks");
+            JToken res = DownloadDataAsync<JToken>(SpotifyWebBuilder.APIBase + "/me/tracks/contains?ids=" + string.Join(",", ids));
+            if (res is JArray) //todo expression is always false
+                return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
+            return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });
+        }
+
         #endregion Library
 
         #region Playlists

From 92e66ed4c3bfebe5ae2fa9a7a63b2a8dae5abe9f Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 14:57:20 +0100
Subject: [PATCH 2/9] Removed parameter checks

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index 900bff58..e4771f38 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -113,8 +113,6 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public FullAlbum GetAlbum(String id, String market = "")
         {
-            if (String.IsNullOrEmpty(market))
-                return DownloadData<FullAlbum>(_builder.SearchItems(id));
             return DownloadData<FullAlbum>(_builder.SearchItems(id, market));
         }
 
@@ -126,8 +124,6 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<FullAlbum> GetAlbumAsync(String id, String market = "")
         {
-            if (String.IsNullOrEmpty(market))
-                return DownloadDataAsync<FullAlbum>(_builder.SearchItems(id));
             return DownloadDataAsync<FullAlbum>(_builder.SearchItems(id, market));
         }
 
@@ -139,8 +135,6 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralAlbums GetSeveralAlbums(List<String> ids, String market = "")
         {
-            if (String.IsNullOrEmpty(market))
-                return DownloadData<SeveralAlbums>(_builder.SearchItems(ids));
             return DownloadData<SeveralAlbums>(_builder.SearchItems(ids, market));
         }
 
@@ -152,8 +146,6 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<SeveralAlbums> GetSeveralAlbumsAsync(List<String> ids, String market = "")
         {
-            if (String.IsNullOrEmpty(market))
-                return DownloadDataAsync<SeveralAlbums>(_builder.SearchItems(ids));
             return DownloadDataAsync<SeveralAlbums>(_builder.SearchItems(ids, market));
         }
 

From ab05201bd223b627709af92dd5ff969b261c4812 Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 15:15:14 +0100
Subject: [PATCH 3/9] Changed UploadData query to _builder

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index e4771f38..b7252870 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -812,7 +812,7 @@ namespace SpotifyAPI.Web
         public ErrorResponse SaveTracks(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadData<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "PUT") ?? new ErrorResponse());
         }
 
         /// <summary>
@@ -824,7 +824,7 @@ namespace SpotifyAPI.Web
         public Task<ErrorResponse> SaveTracksAsync(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadDataAsync<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse());
+            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None)), "PUT") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>
@@ -888,7 +888,7 @@ namespace SpotifyAPI.Web
         public ErrorResponse RemoveSavedTracks(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadData<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -900,7 +900,7 @@ namespace SpotifyAPI.Web
         public Task<ErrorResponse> RemoveSavedTracksAsync(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadDataAsync<ErrorResponse>(SpotifyWebBuilder.APIBase + "/me/tracks/", array.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
+            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>

From 9bb25a81607dbf863de37c2d9560c4bf31ca9df4 Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 15:21:04 +0100
Subject: [PATCH 4/9] Corrected syntax mistake in SaveTracksAsync method

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index b7252870..e1ad5dd1 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -824,7 +824,7 @@ namespace SpotifyAPI.Web
         public Task<ErrorResponse> SaveTracksAsync(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None)), "PUT") ?? Task.FromResult(new ErrorResponse());
+            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse()));
         }
 
         /// <summary>

From dca8d5e3deb3adf7fb8cc74b911099fe483d8519 Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 18:08:24 +0100
Subject: [PATCH 5/9] Corrected all _builder method names until Playlists

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 96 ++++++++++++++++-----------------
 1 file changed, 48 insertions(+), 48 deletions(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index e1ad5dd1..a327ce2a 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -88,7 +88,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Paging<SimpleTrack> GetAlbumTracks(String id, int limit = 20, int offset = 0, String market = "")
         {
-            return DownloadData<Paging<SimpleTrack>>(_builder.SearchItems(id, limit, offset, market));
+            return DownloadData<Paging<SimpleTrack>>(_builder.GetAlbumTracks(id, limit, offset, market));
         }
 
         /// <summary>
@@ -102,7 +102,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<Paging<SimpleTrack>> GetAlbumTracksAsync(String id, int limit = 20, int offset = 0, String market = "")
         {
-            return DownloadDataAsync<Paging<SimpleTrack>>(_builder.SearchItems(id, limit, offset, market));
+            return DownloadDataAsync<Paging<SimpleTrack>>(_builder.GetAlbumTracks(id, limit, offset, market));
         }
 
         /// <summary>
@@ -113,7 +113,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public FullAlbum GetAlbum(String id, String market = "")
         {
-            return DownloadData<FullAlbum>(_builder.SearchItems(id, market));
+            return DownloadData<FullAlbum>(_builder.GetAlbum(id, market));
         }
 
         /// <summary>
@@ -124,7 +124,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<FullAlbum> GetAlbumAsync(String id, String market = "")
         {
-            return DownloadDataAsync<FullAlbum>(_builder.SearchItems(id, market));
+            return DownloadDataAsync<FullAlbum>(_builder.GetAlbum(id, market));
         }
 
         /// <summary>
@@ -135,7 +135,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralAlbums GetSeveralAlbums(List<String> ids, String market = "")
         {
-            return DownloadData<SeveralAlbums>(_builder.SearchItems(ids, market));
+            return DownloadData<SeveralAlbums>(_builder.GetSeveralAlbums(ids, market));
         }
 
         /// <summary>
@@ -146,7 +146,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<SeveralAlbums> GetSeveralAlbumsAsync(List<String> ids, String market = "")
         {
-            return DownloadDataAsync<SeveralAlbums>(_builder.SearchItems(ids, market));
+            return DownloadDataAsync<SeveralAlbums>(_builder.GetSeveralAlbums(ids, market));
         }
 
         #endregion Albums
@@ -160,7 +160,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public FullArtist GetArtist(String id)
         {
-            return DownloadData<FullArtist>(_builder.SearchItems(id));
+            return DownloadData<FullArtist>(_builder.GetArtist(id));
         }
 
         /// <summary>
@@ -170,7 +170,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<FullArtist> GetArtistAsync(String id)
         {
-            return DownloadDataAsync<FullArtist>(_builder.SearchItems(id));
+            return DownloadDataAsync<FullArtist>(_builder.GetArtist(id));
         }
 
         /// <summary>
@@ -181,7 +181,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralArtists GetRelatedArtists(String id)
         {
-            return DownloadData<SeveralArtists>(_builder.SearchItems(id));
+            return DownloadData<SeveralArtists>(_builder.GetRelatedArtists(id));
         }
 
         /// <summary>
@@ -192,7 +192,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<SeveralArtists> GetRelatedArtistsAsync(String id)
         {
-            return DownloadDataAsync<SeveralArtists>(_builder.SearchItems(id));
+            return DownloadDataAsync<SeveralArtists>(_builder.GetRelatedArtists(id));
         }
 
         /// <summary>
@@ -203,7 +203,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralTracks GetArtistsTopTracks(String id, String country)
         {
-            return DownloadData<SeveralTracks>(_builder.SearchItems(id, country));
+            return DownloadData<SeveralTracks>(_builder.GetArtistsTopTracks(id, country));
         }
 
         /// <summary>
@@ -214,7 +214,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<SeveralTracks> GetArtistsTopTracksAsync(String id, String country)
         {
-            return DownloadDataAsync<SeveralTracks>(_builder.SearchItems(id, country));
+            return DownloadDataAsync<SeveralTracks>(_builder.GetArtistsTopTracks(id, country));
         }
 
         /// <summary>
@@ -235,7 +235,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Paging<SimpleAlbum> GetArtistsAlbums(String id, AlbumType type = AlbumType.All, int limit = 20, int offset = 0, String market = "")
         {
-            return DownloadData<Paging<SimpleAlbum>>(_builder.SearchItems(id, type, limit, offset, market));
+            return DownloadData<Paging<SimpleAlbum>>(_builder.GetArtistsAlbums(id, type, limit, offset, market));
         }
 
         /// <summary>
@@ -256,7 +256,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<Paging<SimpleAlbum>> GetArtistsAlbumsAsync(String id, AlbumType type = AlbumType.All, int limit = 20, int offset = 0, String market = "")
         {
-            return DownloadDataAsync<Paging<SimpleAlbum>>(_builder.SearchItems(id, type, limit, offset, market));
+            return DownloadDataAsync<Paging<SimpleAlbum>>(_builder.GetArtistsAlbums(id, type, limit, offset, market));
         }
 
         /// <summary>
@@ -266,7 +266,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralArtists GetSeveralArtists(List<String> ids)
         {
-            return DownloadData<SeveralArtists>(_builder.SearchItems(ids));
+            return DownloadData<SeveralArtists>(_builder.GetSeveralArtists(ids));
         }
 
         /// <summary>
@@ -276,7 +276,7 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public Task<SeveralArtists> GetSeveralArtistsAsync(List<String> ids)
         {
-            return DownloadDataAsync<SeveralArtists>(_builder.SearchItems(ids));
+            return DownloadDataAsync<SeveralArtists>(_builder.GetSeveralArtists(ids));
         }
 
         #endregion Artists
@@ -299,7 +299,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetFeaturedPlaylists");
-            return DownloadData<FeaturedPlaylists>(_builder.SearchItems(locale, country, timestamp, limit, offset));
+            return DownloadData<FeaturedPlaylists>(_builder.GetFeaturedPlaylists(locale, country, timestamp, limit, offset));
         }
 
         /// <summary>
@@ -318,7 +318,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetFeaturedPlaylists");
-            return DownloadDataAsync<FeaturedPlaylists>(_builder.SearchItems(locale, country, timestamp, limit, offset));
+            return DownloadDataAsync<FeaturedPlaylists>(_builder.GetFeaturedPlaylists(locale, country, timestamp, limit, offset));
         }
 
         /// <summary>
@@ -333,7 +333,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetNewAlbumReleases");
-            return DownloadData<NewAlbumReleases>(_builder.SearchItems(country, limit, offset));
+            return DownloadData<NewAlbumReleases>(_builder.GetNewAlbumReleases(country, limit, offset));
         }
 
         /// <summary>
@@ -348,7 +348,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetNewAlbumReleases");
-            return DownloadDataAsync<NewAlbumReleases>(_builder.SearchItems(country, limit, offset));
+            return DownloadDataAsync<NewAlbumReleases>(_builder.GetNewAlbumReleases(country, limit, offset));
         }
 
         /// <summary>
@@ -370,7 +370,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetCategories");
-            return DownloadData<CategoryList>(_builder.SearchItems(country, locale, limit, offset));
+            return DownloadData<CategoryList>(_builder.GetCategories(country, locale, limit, offset));
         }
 
         /// <summary>
@@ -392,7 +392,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetCategories");
-            return DownloadDataAsync<CategoryList>(_builder.SearchItems(country, locale, limit, offset));
+            return DownloadDataAsync<CategoryList>(_builder.GetCategories(country, locale, limit, offset));
         }
 
         /// <summary>
@@ -411,7 +411,7 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public Category GetCategory(String categoryId, String country = "", String locale = "")
         {
-            return DownloadData<Category>(_builder.SearchItems(categoryId, country, locale));
+            return DownloadData<Category>(_builder.GetCategory(categoryId, country, locale));
         }
 
         /// <summary>
@@ -430,7 +430,7 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public Task<Category> GetCategoryAsync(String categoryId, String country = "", String locale = "")
         {
-            return DownloadDataAsync<Category>(_builder.SearchItems(categoryId, country, locale));
+            return DownloadDataAsync<Category>(_builder.GetCategory(categoryId, country, locale));
         }
 
         /// <summary>
@@ -444,7 +444,7 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public CategoryPlaylist GetCategoryPlaylists(String categoryId, String country = "", int limit = 20, int offset = 0)
         {
-            return DownloadData<CategoryPlaylist>(_builder.SearchItems(categoryId, country, limit, offset));
+            return DownloadData<CategoryPlaylist>(_builder.GetCategoryPlaylists(categoryId, country, limit, offset));
         }
 
         /// <summary>
@@ -458,7 +458,7 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public Task<CategoryPlaylist> GetCategoryPlaylistsAsync(String categoryId, String country = "", int limit = 20, int offset = 0)
         {
-            return DownloadDataAsync<CategoryPlaylist>(_builder.SearchItems(categoryId, country, limit, offset));
+            return DownloadDataAsync<CategoryPlaylist>(_builder.GetCategoryPlaylists(categoryId, country, limit, offset));
         }
 
         #endregion Browse
@@ -477,7 +477,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetFollowedArtists");
-            return DownloadData<FollowedArtists>(_builder.SearchItems(followType, limit, after));
+            return DownloadData<FollowedArtists>(_builder.GetFollowedArtists(followType, limit, after));
         }
 
         /// <summary>
@@ -492,7 +492,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetFollowedArtists");
-            return DownloadDataAsync<FollowedArtists>(_builder.SearchItems(followType, limit, after));
+            return DownloadDataAsync<FollowedArtists>(_builder.GetFollowedArtists(followType, limit, after));
         }
 
         /// <summary>
@@ -508,7 +508,7 @@ namespace SpotifyAPI.Web
             {
                 {"ids", new JArray(ids)}
             };
-            return UploadData<ErrorResponse>(_builder.SearchItems(followType, ids), ob.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.Follow(followType, ids), ob.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -525,7 +525,7 @@ namespace SpotifyAPI.Web
                 {"ids", new JArray(ids)}
             };
             return
-                UploadDataAsync<ErrorResponse>(_builder.SearchItems(followType, ids),
+                UploadDataAsync<ErrorResponse>(_builder.Follow(followType, ids),
                     ob.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse());
         }
 
@@ -566,7 +566,7 @@ namespace SpotifyAPI.Web
             {
                 {"ids", new JArray(ids)}
             };
-            return UploadData<ErrorResponse>(_builder.SearchItems(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.Unfollow(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -582,7 +582,7 @@ namespace SpotifyAPI.Web
             {
                 {"ids", new JArray(ids)}
             };
-            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
+            return UploadDataAsync<ErrorResponse>(_builder.Unfollow(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>
@@ -620,7 +620,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowing");
-            JToken res = DownloadData<JToken>(_builder.SearchItems(followType, ids));
+            JToken res = DownloadData<JToken>(_builder.IsFollowing(followType, ids));
             if (res is JArray)
                 return new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null };
             return new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() };
@@ -637,7 +637,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowing");
-            JToken res = DownloadDataAsync<JToken>(_builder.SearchItems(followType, ids));
+            JToken res = DownloadDataAsync<JToken>(_builder.IsFollowing(followType, ids));
             if (res is JArray) //todo expression is always false
                 return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
             return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });
@@ -687,7 +687,7 @@ namespace SpotifyAPI.Web
             {
                 {"public", showPublic}
             };
-            return UploadData<ErrorResponse>(_builder.SearchItems(ownerId, playlistId, showPublic), body.ToString(Formatting.None), "PUT");
+            return UploadData<ErrorResponse>(_builder.FollowPlaylist(ownerId, playlistId, showPublic), body.ToString(Formatting.None), "PUT");
         }
 
         /// <summary>
@@ -710,7 +710,7 @@ namespace SpotifyAPI.Web
             {
                 {"public", showPublic}
             };
-            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(ownerId, playlistId, showPublic), body.ToString(Formatting.None), "PUT");
+            return UploadDataAsync<ErrorResponse>(_builder.FollowPlaylist(ownerId, playlistId, showPublic), body.ToString(Formatting.None), "PUT");
         }
 
         /// <summary>
@@ -722,7 +722,7 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public ErrorResponse UnfollowPlaylist(String ownerId, String playlistId)
         {
-            return UploadData<ErrorResponse>(_builder.SearchItems(ownerId, playlistId), "", "DELETE");
+            return UploadData<ErrorResponse>(_builder.UnfollowPlaylist(ownerId, playlistId), "", "DELETE");
         }
 
         /// <summary>
@@ -734,7 +734,7 @@ namespace SpotifyAPI.Web
         /// <remarks>AUTH NEEDED</remarks>
         public Task<ErrorResponse> UnfollowPlaylistAsync(String ownerId, String playlistId)
         {
-            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(ownerId, playlistId), "", "DELETE");
+            return UploadDataAsync<ErrorResponse>(_builder.UnfollowPlaylist(ownerId, playlistId), "", "DELETE");
         }
 
         /// <summary>
@@ -749,7 +749,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowingPlaylist");
-            JToken res = DownloadData<JToken>(_builder.SearchItems(ownerId, playlistId, ids));
+            JToken res = DownloadData<JToken>(_builder.IsFollowingPlaylist(ownerId, playlistId, ids));
             if (res is JArray)
                 return new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null };
             return new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() };
@@ -767,7 +767,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowingPlaylist");
-            JToken res = DownloadDataAsync<JToken>(_builder.SearchItems(ownerId, playlistId, ids));
+            JToken res = DownloadDataAsync<JToken>(_builder.IsFollowingPlaylist(ownerId, playlistId, ids));
             if (res is JArray) //todo expression is always false
                 return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
             return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });
@@ -812,7 +812,7 @@ namespace SpotifyAPI.Web
         public ErrorResponse SaveTracks(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadData<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "PUT") ?? new ErrorResponse());
+            return UploadData<ErrorResponse>(_builder.SaveTracks(array.ToString(Formatting.None), "PUT") ?? new ErrorResponse());
         }
 
         /// <summary>
@@ -824,7 +824,7 @@ namespace SpotifyAPI.Web
         public Task<ErrorResponse> SaveTracksAsync(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse()));
+            return UploadDataAsync<ErrorResponse>(_builder.SaveTracks(array.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse()));
         }
 
         /// <summary>
@@ -861,7 +861,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetSavedTracks");
-            return DownloadData<Paging<SavedTrack>>(_builder.SearchItems(limit, offset, market));
+            return DownloadData<Paging<SavedTrack>>(_builder.GetSavedTracks(limit, offset, market));
         }
 
         /// <summary>
@@ -876,7 +876,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetSavedTracks");
-            return DownloadDataAsync<Paging<SavedTrack>>(_builder.SearchItems(limit, offset, market));
+            return DownloadDataAsync<Paging<SavedTrack>>(_builder.GetSavedTracks(limit, offset, market));
         }
 
         /// <summary>
@@ -888,7 +888,7 @@ namespace SpotifyAPI.Web
         public ErrorResponse RemoveSavedTracks(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadData<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.RemoveSavedTracks(array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -900,7 +900,7 @@ namespace SpotifyAPI.Web
         public Task<ErrorResponse> RemoveSavedTracksAsync(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadDataAsync<ErrorResponse>(_builder.SearchItems(array.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
+            return UploadDataAsync<ErrorResponse>(_builder.RemoveSavedTracks(array.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
         }
 
         /// <summary>
@@ -913,7 +913,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for CheckSavedTracks");
-            JToken res = DownloadData<JToken>(APIBase + "/me/tracks/contains?ids=" + string.Join(",", ids));
+            JToken res = DownloadData<JToken>(_builder.CheckSavedTracks(ids));
             if (res is JArray)
                 return new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null };
             return new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() };
@@ -929,7 +929,7 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for CheckSavedTracks");
-            JToken res = DownloadDataAsync<JToken>(SpotifyWebBuilder.APIBase + "/me/tracks/contains?ids=" + string.Join(",", ids));
+            JToken res = DownloadDataAsync<JToken>(_builder.CheckSavedTracks(ids));
             if (res is JArray) //todo expression is always false
                 return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
             return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });

From a6c3d33abc34390bd4463efe08f3c01d0dc90354 Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 19:21:30 +0100
Subject: [PATCH 6/9]  Added Async Methods for Playlists/Profiles/Tracks

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 296 ++++++++++++++++++++++++++++----
 1 file changed, 262 insertions(+), 34 deletions(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index a327ce2a..c39b1771 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -951,11 +951,22 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetUserPlaylists");
-            limit = Math.Min(limit, 50);
-            StringBuilder builder = new StringBuilder(APIBase + "/users/" + userId + "/playlists");
-            builder.Append("?limit=" + limit);
-            builder.Append("&offset=" + offset);
-            return DownloadData<Paging<SimplePlaylist>>(builder.ToString());
+            return DownloadData<Paging<SimplePlaylist>>(_builder.GetUserPlaylists(userId, limit, offset));
+        }
+
+        /// <summary>
+        ///     Get a list of the playlists owned or followed by a Spotify user asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="limit">The maximum number of playlists to return. Default: 20. Minimum: 1. Maximum: 50. </param>
+        /// <param name="offset">The index of the first playlist to return. Default: 0 (the first object)</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<Paging<SimplePlaylist>> GetUserPlaylistsAsync(String userId, int limit = 20, int offset = 0)
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetUserPlaylists");
+            return DownloadDataAsync<Paging<SimplePlaylist>>(_builder.GetUserPlaylists(userId, limit, offset));
         }
 
         /// <summary>
@@ -974,11 +985,26 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetPlaylist");
-            StringBuilder builder = new StringBuilder(APIBase + "/users/" + userId + "/playlists/" + playlistId);
-            builder.Append("?fields=" + fields);
-            if (!String.IsNullOrEmpty(market))
-                builder.Append("&market=" + market);
-            return DownloadData<FullPlaylist>(builder.ToString());
+            return DownloadData<FullPlaylist>(_builder.GetPlaylist(userId, playlistId, fields, market));
+        }
+
+        /// <summary>
+        ///     Get a playlist owned by a Spotify user asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="fields">
+        ///     Filters for the query: a comma-separated list of the fields to return. If omitted, all fields are
+        ///     returned.
+        /// </param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<FullPlaylist> GetPlaylistAsync(String userId, String playlistId, String fields = "", String market = "")
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetPlaylist");
+            return DownloadDataAsync<FullPlaylist>(_builder.GetPlaylist(userId, playlistId, fields, market));
         }
 
         /// <summary>
@@ -999,14 +1025,28 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetPlaylistTracks");
-            limit = Math.Max(limit, 100);
-            StringBuilder builder = new StringBuilder(APIBase + "/users/" + userId + "/playlists/" + playlistId + "/tracks");
-            builder.Append("?fields=" + fields);
-            builder.Append("&limit=" + limit);
-            builder.Append("&offset=" + offset);
-            if (!String.IsNullOrEmpty(market))
-                builder.Append("&market=" + market);
-            return DownloadData<Paging<PlaylistTrack>>(builder.ToString());
+            return DownloadData<Paging<PlaylistTrack>>(_builder.GetPlaylistTracks(userId, playlistId, fields, limit, offset, market));
+        }
+
+        /// <summary>
+        ///     Get full details of the tracks of a playlist owned by a Spotify user asyncronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="fields">
+        ///     Filters for the query: a comma-separated list of the fields to return. If omitted, all fields are
+        ///     returned.
+        /// </param>
+        /// <param name="limit">The maximum number of tracks to return. Default: 100. Minimum: 1. Maximum: 100.</param>
+        /// <param name="offset">The index of the first object to return. Default: 0 (i.e., the first object)</param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<Paging<PlaylistTrack>> GetPlaylistTracksAsync(String userId, String playlistId, String fields = "", int limit = 100, int offset = 0, String market = "")
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetPlaylistTracks");
+            return DownloadDataAsync<Paging<PlaylistTrack>>(_builder.GetPlaylistTracks(userId, playlistId, fields, limit, offset, market));
         }
 
         /// <summary>
@@ -1030,7 +1070,31 @@ namespace SpotifyAPI.Web
                 {"name", playlistName},
                 {"public", isPublic}
             };
-            return UploadData<FullPlaylist>(APIBase + "/users/" + userId + "/playlists", body.ToString(Formatting.None));
+            return UploadData<FullPlaylist>(_builder.CreatePlaylist(userId, playlistName, isPublic), body.ToString(Formatting.None));
+        }
+
+        /// <summary>
+        ///     Create a playlist for a Spotify user asynchronously. (The playlist will be empty until you add tracks.)
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistName">
+        ///     The name for the new playlist, for example "Your Coolest Playlist". This name does not need
+        ///     to be unique.
+        /// </param>
+        /// <param name="isPublic">
+        ///     default true. If true the playlist will be public, if false it will be private. To be able to
+        ///     create private playlists, the user must have granted the playlist-modify-private scope.
+        /// </param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<FullPlaylist> CreatePlaylistAsync(String userId, String playlistName, Boolean isPublic = true)
+        {
+            JObject body = new JObject
+            {
+                {"name", playlistName},
+                {"public", isPublic}
+            };
+            return UploadDataAsync<FullPlaylist>(_builder.CreatePlaylist(userId, playlistName, isPublic), body.ToString(Formatting.None));
         }
 
         /// <summary>
@@ -1049,7 +1113,26 @@ namespace SpotifyAPI.Web
                 body.Add("name", newName);
             if (newPublic != null)
                 body.Add("public", newPublic);
-            return UploadData<ErrorResponse>(APIBase + "/users/" + userId + "/playlists/" + playlistId, body.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.UpdatePlaylist(userId, playlistId, newName, newPublic), body.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+        }
+
+        /// <summary>
+        ///     Change a playlist’s name and public/private state asynchronously. (The user must, of course, own the playlist.)
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="newName">The new name for the playlist, for example "My New Playlist Title".</param>
+        /// <param name="newPublic">If true the playlist will be public, if false it will be private.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> UpdatePlaylistAsync(String userId, String playlistId, String newName = null, Boolean? newPublic = null)
+        {
+            JObject body = new JObject();
+            if (newName != null)
+                body.Add("name", newName);
+            if (newPublic != null)
+                body.Add("public", newPublic);
+            return UploadDataAsync<ErrorResponse>(_builder.UpdatePlaylist(userId, playlistId, newName, newPublic), body.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -1067,7 +1150,25 @@ namespace SpotifyAPI.Web
             {
                 {"uris", new JArray(uris.Take(100))}
             };
-            return UploadData<ErrorResponse>(APIBase + "/users/" + userId + "/playlists/" + playlistId + "/tracks", body.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.ReplacePlaylistTracks(userId, playlistId, uris), body.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
+        }
+
+        /// <summary>
+        ///     Replace all the tracks in a playlist asynchronously, overwriting its existing tracks. This powerful request can be useful for
+        ///     replacing tracks, re-ordering existing tracks, or clearing the playlist.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="uris">A list of Spotify track URIs to set. A maximum of 100 tracks can be set in one request.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> ReplacePlaylistTracksAsync(String userId, String playlistId, List<String> uris)
+        {
+            JObject body = new JObject
+            {
+                {"uris", new JArray(uris.Take(100))}
+            };
+            return UploadDataAsync<ErrorResponse>(_builder.ReplacePlaylistTracks(userId, playlistId, uris), body.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -1087,7 +1188,27 @@ namespace SpotifyAPI.Web
             {
                 {"tracks", JArray.FromObject(uris.Take(100))}
             };
-            return UploadData<ErrorResponse>(APIBase + "/users/" + userId + "/playlists/" + playlistId + "/tracks", body.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.RemovePlaylistTracks(userId, playlistId, uris), body.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+        }
+
+        /// <summary>
+        ///     Remove one or more tracks from a user’s playlist asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="uris">
+        ///     array of objects containing Spotify URI strings (and their position in the playlist). A maximum of
+        ///     100 objects can be sent at once.
+        /// </param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> RemovePlaylistTracksAsync(String userId, String playlistId, List<DeleteTrackUri> uris)
+        {
+            JObject body = new JObject
+            {
+                {"tracks", JArray.FromObject(uris.Take(100))}
+            };
+            return UploadDataAsync<ErrorResponse>(_builder.RemovePlaylistTracks(userId, playlistId, uris), body.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -1103,6 +1224,19 @@ namespace SpotifyAPI.Web
             return RemovePlaylistTracks(userId, playlistId, new List<DeleteTrackUri> { uri });
         }
 
+        /// <summary>
+        ///     Remove one or more tracks from a user’s playlist asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="uri">Spotify URI</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> RemovePlaylistTrackAsync(String userId, String playlistId, DeleteTrackUri uri)
+        {
+            return RemovePlaylistTracksAsync(userId, playlistId, new List<DeleteTrackUri> { uri });
+        }
+
         /// <summary>
         ///     Add one or more tracks to a user’s playlist.
         /// </summary>
@@ -1118,9 +1252,27 @@ namespace SpotifyAPI.Web
             {
                 {"uris", JArray.FromObject(uris.Take(100))}
             };
-            if (position == null)
-                return UploadData<ErrorResponse>(APIBase + "/users/" + userId + "/playlists/" + playlistId + "/tracks", body.ToString(Formatting.None)) ?? new ErrorResponse();
-            return UploadData<ErrorResponse>(APIBase + "/users/" + userId + "/playlists/" + playlistId + "/tracks?position=" + position, body.ToString(Formatting.None)) ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.AddPlaylistTracks(userId, playlistId, uris, position), body.ToString(Formatting.None)) ?? new ErrorResponse();
+
+        }
+
+        /// <summary>
+        ///     Add one or more tracks to a user’s playlist asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="uris">A list of Spotify track URIs to add</param>
+        /// <param name="position">The position to insert the tracks, a zero-based index</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> AddPlaylistTracksAsync(String userId, String playlistId, List<String> uris, int? position = null)
+        {
+            JObject body = new JObject
+            {
+                {"uris", JArray.FromObject(uris.Take(100))}
+            };
+            return UploadDataAsync<ErrorResponse>(_builder.AddPlaylistTracks(userId, playlistId, uris, position), body.ToString(Formatting.None)) ?? new ErrorResponse();
+
         }
 
         /// <summary>
@@ -1137,6 +1289,20 @@ namespace SpotifyAPI.Web
             return AddPlaylistTracks(userId, playlistId, new List<string> { uri }, position);
         }
 
+        /// <summary>
+        ///     Add one or more tracks to a user’s playlist asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="uri">A Spotify Track URI</param>
+        /// <param name="position">The position to insert the tracks, a zero-based index</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<ErrorResponse> AddPlaylistTrackAsync(String userId, String playlistId, String uri, int? position = null)
+        {
+            return AddPlaylistTracksAsync(userId, playlistId, new List<string> { uri }, position);
+        }
+
         /// <summary>
         ///     Reorder a track or a group of tracks in a playlist.
         /// </summary>
@@ -1158,7 +1324,29 @@ namespace SpotifyAPI.Web
             };
             if (!String.IsNullOrEmpty(snapshotId))
                 body.Add("snapshot_id", snapshotId);
-            return UploadData<Snapshot>(APIBase + "/users/" + userId + "/playlists/" + playlistId + "/tracks", body.ToString(Formatting.None), "PUT");
+            return UploadData<Snapshot>(_builder.ReorderPlaylist(userId, playlistId, rangeStart, insertBefore, rangeLength, snapshotId), body.ToString(Formatting.None), "PUT");
+        }
+
+        /// <summary>
+        ///     Reorder a track or a group of tracks in a playlist asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <param name="playlistId">The Spotify ID for the playlist.</param>
+        /// <param name="rangeStart">The position of the first track to be reordered.</param>
+        /// <param name="insertBefore">The position where the tracks should be inserted. </param>
+        /// <param name="rangeLength">The amount of tracks to be reordered. Defaults to 1 if not set.</param>
+        /// <param name="snapshotId">The playlist's snapshot ID against which you want to make the changes.</param>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<Snapshot> ReorderPlaylistAsync(String userId, String playlistId, int rangeStart, int insertBefore, int rangeLength = 1, String snapshotId = "")
+        {
+            JObject body = new JObject
+            {
+                {"range_start", rangeStart},
+                {"range_length", rangeLength},
+                {"insert_before", insertBefore}
+            };
+            return UploadDataAsync<Snapshot>(_builder.ReorderPlaylist(userId, playlistId, rangeStart, insertBefore, rangeLength, snapshotId), body.ToString(Formatting.None), "PUT");
         }
 
         #endregion Playlists
@@ -1174,7 +1362,19 @@ namespace SpotifyAPI.Web
         {
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for GetPrivateProfile");
-            return DownloadData<PrivateProfile>(APIBase + "/me");
+            return DownloadData<PrivateProfile>(_builder.GetPrivateProfile());
+        }
+
+        /// <summary>
+        ///     Get detailed profile information about the current user asynchronously (including the current user’s username).
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks>AUTH NEEDED</remarks>
+        public Task<PrivateProfile> GetPrivateProfileAsync()
+        {
+            if (!UseAuth)
+                throw new InvalidOperationException("Auth is required for GetPrivateProfile");
+            return DownloadDataAsync<PrivateProfile>(_builder.GetPrivateProfile());
         }
 
         /// <summary>
@@ -1184,7 +1384,17 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public PublicProfile GetPublicProfile(String userId)
         {
-            return DownloadData<PublicProfile>(APIBase + "/users/" + userId);
+            return DownloadData<PublicProfile>(_builder.GetPublicProfile(userId));
+        }
+
+        /// <summary>
+        ///     Get public profile information about a Spotify user asynchronously.
+        /// </summary>
+        /// <param name="userId">The user's Spotify user ID.</param>
+        /// <returns></returns>
+        public Task<PublicProfile> GetPublicProfileAsync(String userId)
+        {
+            return DownloadDataAsync<PublicProfile>(_builder.GetPublicProfile(userId));
         }
 
         #endregion Profiles
@@ -1199,9 +1409,18 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public SeveralTracks GetSeveralTracks(List<String> ids, String market = "")
         {
-            if (String.IsNullOrEmpty(market))
-                return DownloadData<SeveralTracks>(APIBase + "/tracks?ids=" + string.Join(",", ids.Take(50)));
-            return DownloadData<SeveralTracks>(APIBase + "/tracks?market=" + market + "&ids=" + string.Join(",", ids.Take(50)));
+            return DownloadData<SeveralTracks>(_builder.GetSeveralTracks(ids, market));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information for multiple tracks based on their Spotify IDs asynchronously.
+        /// </summary>
+        /// <param name="ids">A list of the Spotify IDs for the tracks. Maximum: 50 IDs.</param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        public Task<SeveralTracks> GetSeveralTracksAsync(List<String> ids, String market = "")
+        {
+            return DownloadDataAsync<SeveralTracks>(_builder.GetSeveralTracks(ids, market));
         }
 
         /// <summary>
@@ -1212,9 +1431,18 @@ namespace SpotifyAPI.Web
         /// <returns></returns>
         public FullTrack GetTrack(String id, String market = "")
         {
-            if (String.IsNullOrEmpty(market))
-                return DownloadData<FullTrack>(APIBase + "/tracks/" + id);
-            return DownloadData<FullTrack>(APIBase + "/tracks/" + id + "?market=" + market);
+            return DownloadData<FullTrack>(_builder.GetTrack(id, market));
+        }
+
+        /// <summary>
+        ///     Get Spotify catalog information for a single track identified by its unique Spotify ID asynchronously.
+        /// </summary>
+        /// <param name="id">The Spotify ID for the track.</param>
+        /// <param name="market">An ISO 3166-1 alpha-2 country code. Provide this parameter if you want to apply Track Relinking.</param>
+        /// <returns></returns>
+        public Task<FullTrack> GetTrackAsync(String id, String market = "")
+        {
+            return DownloadDataAsync<FullTrack>(_builder.GetTrack(id, market));
         }
 
         #endregion Tracks

From d3b6913690fdc9ea04803ee9e2840e2aaa75f2fa Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 19:31:20 +0100
Subject: [PATCH 7/9] Removed Task.FromResult where not needed

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index c39b1771..f82c167c 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -526,7 +526,7 @@ namespace SpotifyAPI.Web
             };
             return
                 UploadDataAsync<ErrorResponse>(_builder.Follow(followType, ids),
-                    ob.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse());
+                    ob.ToString(Formatting.None), "PUT") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -582,7 +582,7 @@ namespace SpotifyAPI.Web
             {
                 {"ids", new JArray(ids)}
             };
-            return UploadDataAsync<ErrorResponse>(_builder.Unfollow(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
+            return UploadDataAsync<ErrorResponse>(_builder.Unfollow(followType, ids), ob.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
         }
 
         /// <summary>
@@ -824,7 +824,7 @@ namespace SpotifyAPI.Web
         public Task<ErrorResponse> SaveTracksAsync(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadDataAsync<ErrorResponse>(_builder.SaveTracks(array.ToString(Formatting.None), "PUT") ?? Task.FromResult(new ErrorResponse()));
+            return UploadDataAsync<ErrorResponse>(_builder.SaveTracks(array.ToString(Formatting.None), "PUT") ?? new ErrorResponse());
         }
 
         /// <summary>
@@ -888,7 +888,7 @@ namespace SpotifyAPI.Web
         public ErrorResponse RemoveSavedTracks(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadData<ErrorResponse>(_builder.RemoveSavedTracks(array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse();
+            return UploadData<ErrorResponse>(_builder.RemoveSavedTracks(array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse());
         }
 
         /// <summary>
@@ -900,7 +900,7 @@ namespace SpotifyAPI.Web
         public Task<ErrorResponse> RemoveSavedTracksAsync(List<String> ids)
         {
             JArray array = new JArray(ids);
-            return UploadDataAsync<ErrorResponse>(_builder.RemoveSavedTracks(array.ToString(Formatting.None), "DELETE") ?? Task.FromResult(new ErrorResponse());
+            return UploadDataAsync<ErrorResponse>(_builder.RemoveSavedTracks(array.ToString(Formatting.None), "DELETE") ?? new ErrorResponse());
         }
 
         /// <summary>

From a913f1d459dd9c5c82237e5fd8919c8ce09d55f1 Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 19:44:52 +0100
Subject: [PATCH 8/9] Added 3 compilebreakers on Todo Items

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index f82c167c..30f55096 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -638,6 +638,7 @@ namespace SpotifyAPI.Web
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowing");
             JToken res = DownloadDataAsync<JToken>(_builder.IsFollowing(followType, ids));
+# Compilebreaker
             if (res is JArray) //todo expression is always false
                 return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
             return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });
@@ -768,6 +769,7 @@ namespace SpotifyAPI.Web
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for IsFollowingPlaylist");
             JToken res = DownloadDataAsync<JToken>(_builder.IsFollowingPlaylist(ownerId, playlistId, ids));
+# Compilebreaker
             if (res is JArray) //todo expression is always false
                 return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
             return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });
@@ -930,6 +932,7 @@ namespace SpotifyAPI.Web
             if (!UseAuth)
                 throw new InvalidOperationException("Auth is required for CheckSavedTracks");
             JToken res = DownloadDataAsync<JToken>(_builder.CheckSavedTracks(ids));
+# Compilebreaker
             if (res is JArray) //todo expression is always false
                 return Task.FromResult(new ListResponse<Boolean> { List = res.ToObject<List<Boolean>>(), Error = null });
             return Task.FromResult(new ListResponse<Boolean> { List = null, Error = res["error"].ToObject<Error>() });

From c51a2679246ae32abdfc76083b34c68a22cfbdc7 Mon Sep 17 00:00:00 2001
From: Jimmy Appelt <jim.appelt@gmail.com>
Date: Fri, 6 Nov 2015 19:56:50 +0100
Subject: [PATCH 9/9] CM Clean

---
 SpotifyAPI/Web/SpotifyWebAPI.cs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/SpotifyAPI/Web/SpotifyWebAPI.cs b/SpotifyAPI/Web/SpotifyWebAPI.cs
index 30f55096..79763111 100644
--- a/SpotifyAPI/Web/SpotifyWebAPI.cs
+++ b/SpotifyAPI/Web/SpotifyWebAPI.cs
@@ -5,7 +5,6 @@ using SpotifyAPI.Web.Models;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace SpotifyAPI.Web
@@ -1256,7 +1255,6 @@ namespace SpotifyAPI.Web
                 {"uris", JArray.FromObject(uris.Take(100))}
             };
             return UploadData<ErrorResponse>(_builder.AddPlaylistTracks(userId, playlistId, uris, position), body.ToString(Formatting.None)) ?? new ErrorResponse();
-
         }
 
         /// <summary>
@@ -1275,7 +1273,6 @@ namespace SpotifyAPI.Web
                 {"uris", JArray.FromObject(uris.Take(100))}
             };
             return UploadDataAsync<ErrorResponse>(_builder.AddPlaylistTracks(userId, playlistId, uris, position), body.ToString(Formatting.None)) ?? new ErrorResponse();
-
         }
 
         /// <summary>