Use inline uri classes

* Added use of uri classes

Author: molikuner

src/main/kotlin/com/adamratzman/spotify/endpoints/client/ClientFollowingAPI.kt

@@ -19,9 +19,9 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if [userId] is a non-existing id
      */
-    fun isFollowingUser(userId: String): SpotifyRestAction<Boolean> {
+    fun isFollowingUser(user: String): SpotifyRestAction<Boolean> {
         return toAction(Supplier {
-            isFollowingUsers(userId).complete()[0]
+            isFollowingUsers(user).complete()[0]
         })
     }
 
@@ -46,10 +46,10 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if [userIds] contains a non-existing id
      */
-    fun isFollowingUsers(vararg userIds: String): SpotifyRestAction<List<Boolean>> {
+    fun isFollowingUsers(vararg users: String): SpotifyRestAction<List<Boolean>> {
         return toAction(Supplier {
             get(EndpointBuilder("/me/following/contains").with("type", "user")
-                    .with("ids", userIds.joinToString(",") { it.encode() }).toString()).toObject(api, mutableListOf<Boolean>().javaClass).toList()
+                    .with("ids", users.joinToString(",") { UserURI(it).id.encode() }).toString()).toObject(api, mutableListOf<Boolean>().javaClass).toList()
         })
     }
 
@@ -60,9 +60,9 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if [artistId] is a non-existing id
      */
-    fun isFollowingArtist(artistId: String): SpotifyRestAction<Boolean> {
+    fun isFollowingArtist(artist: String): SpotifyRestAction<Boolean> {
         return toAction(Supplier {
-            isFollowingArtists(artistId).complete()[0]
+            isFollowingArtists(artist).complete()[0]
         })
     }
 
@@ -73,10 +73,10 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if [artistIds] contains a non-existing id
      */
-    fun isFollowingArtists(vararg artistIds: String): SpotifyRestAction<List<Boolean>> {
+    fun isFollowingArtists(vararg artists: String): SpotifyRestAction<List<Boolean>> {
         return toAction(Supplier {
             get(EndpointBuilder("/me/following/contains").with("type", "artist")
-                    .with("ids", artistIds.joinToString(",") { it.encode() }).toString()).toObject(api, mutableListOf<Boolean>().javaClass).toList()
+                    .with("ids", artists.joinToString(",") { ArtistURI(it).id.encode() }).toString()).toObject(api, mutableListOf<Boolean>().javaClass).toList()
         })
     }
 
@@ -100,9 +100,9 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if an invalid id is provided
      */
-    fun followUser(userId: String): SpotifyRestAction<Unit> {
+    fun followUser(user: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
-            followUsers(userId).complete()
+            followUsers(user).complete()
         })
     }
 
@@ -111,10 +111,10 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if an invalid id is provided
      */
-    fun followUsers(vararg userIds: String): SpotifyRestAction<Unit> {
+    fun followUsers(vararg users: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
             put(EndpointBuilder("/me/following").with("type", "user")
-                    .with("ids", userIds.joinToString(",") { it.encode() }).toString())
+                    .with("ids", users.joinToString(",") { UserURI(it).id.encode() }).toString())
             Unit
         })
     }
@@ -135,28 +135,27 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if an invalid id is provided
      */
-    fun followArtists(vararg artistIds: String): SpotifyRestAction<Unit> {
+    fun followArtists(vararg artists: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
             put(EndpointBuilder("/me/following").with("type", "artist")
-                    .with("ids", artistIds.joinToString(",") { it.encode() }).toString())
+                    .with("ids", artists.joinToString(",") { ArtistURI(it).id.encode() }).toString())
             Unit
         })
     }
 
     /**
      * Add the current user as a follower of a playlist.
      *
-     * @param ownerId The Spotify user ID of the person who owns the playlist.
-     * @param playlistId The Spotify ID of the playlist. Any playlist can be followed, regardless of its
+     * @param playlist 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 followPublicly Defaults to true. If true the playlist will be included in user’s public playlists,
      * if false it will remain private. To be able to follow playlists privately, the user must have granted the playlist-modify-private scope.
      *
      * @throws BadRequestException if the playlist is not found
      */
-    fun followPlaylist(playlistId: String, followPublicly: Boolean = true): SpotifyRestAction<Unit> {
+    fun followPlaylist(playlist: String, followPublicly: Boolean = true): SpotifyRestAction<Unit> {
         return toAction(Supplier {
-            put(EndpointBuilder("/playlists/$playlistId/followers").toString(), "{\"public\": $followPublicly}")
+            put(EndpointBuilder("/playlists/${PlaylistURI(playlist).id}/followers").toString(), "{\"public\": $followPublicly}")
             Unit
         })
 
@@ -169,9 +168,9 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if [userId] is not found
      */
-    fun unfollowUser(userId: String): SpotifyRestAction<Unit> {
+    fun unfollowUser(user: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
-            unfollowUsers(userId).complete()
+            unfollowUsers(user).complete()
         })
     }
 
@@ -182,10 +181,10 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if an invalid id is provided
      */
-    fun unfollowUsers(vararg userIds: String): SpotifyRestAction<Unit> {
+    fun unfollowUsers(vararg users: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
             delete(EndpointBuilder("/me/following").with("type", "user")
-                    .with("ids", userIds.joinToString(",") { it.encode() }).toString())
+                    .with("ids", users.joinToString(",") { UserURI(it).id.encode() }).toString())
             Unit
         })
     }
@@ -197,9 +196,9 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if an invalid id is provided
      */
-    fun unfollowArtist(artistId: String): SpotifyRestAction<Unit> {
+    fun unfollowArtist(artist: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
-            unfollowArtists(artistId).complete()
+            unfollowArtists(artist).complete()
         })
     }
 
@@ -210,26 +209,25 @@ class ClientFollowingAPI(api: SpotifyAPI) : FollowingAPI(api) {
      *
      * @throws BadRequestException if an invalid id is provided
      */
-    fun unfollowArtists(vararg artistIds: String): SpotifyRestAction<Unit> {
+    fun unfollowArtists(vararg artists: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
             delete(EndpointBuilder("/me/following").with("type", "artist")
-                    .with("ids", artistIds.joinToString(",") { it.encode() }).toString())
+                    .with("ids", artists.joinToString(",") { ArtistURI(it).id.encode() }).toString())
             Unit
         })
     }
 
     /**
      * Remove the current user as a follower of a playlist.
      *
-     * @param ownerId The Spotify user ID of the person who owns the playlist.
      * @param playlistId The Spotify ID of the playlist that is to be no longer followed.
      *
      * @throws BadRequestException if the playlist is not found
      */
-    fun unfollowPlaylist(playlistId: String): SpotifyRestAction<Unit> {
+    fun unfollowPlaylist(playlist: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
-            delete(EndpointBuilder("/playlists/$playlistId/followers").toString())
+            delete(EndpointBuilder("/playlists/${PlaylistURI(playlist).id}/followers").toString())
             Unit
         })
     }
-}
+}

src/main/kotlin/com/adamratzman/spotify/endpoints/client/ClientLibraryAPI.kt

@@ -37,7 +37,7 @@ class ClientLibraryAPI(api: SpotifyAPI) : SpotifyEndpoint(api) {
     /**
      * Check if the [LibraryType] with id [id] is already saved in the current Spotify user’s ‘Your Music’ library.
      *
-     * @throws BadRequestException if [id] is not found
+     * @throws BadRequestException if [track] is not found
      */
     fun contains(type: LibraryType, id: String): SpotifyRestAction<Boolean> {
         return toAction(Supplier {
@@ -52,7 +52,7 @@ class ClientLibraryAPI(api: SpotifyAPI) : SpotifyEndpoint(api) {
      */
     fun contains(type: LibraryType, vararg ids: String): SpotifyRestAction<List<Boolean>> {
         return toAction(Supplier {
-            get(EndpointBuilder("/me/$type/contains").with("ids", ids.joinToString(",") { it.encode() })
+            get(EndpointBuilder("/me/$type/contains").with("ids", ids.joinToString(",") { type.id(it).encode() })
                     .toString()).toObject(api, mutableListOf<Boolean>().javaClass).toList()
         })
     }
@@ -75,7 +75,7 @@ class ClientLibraryAPI(api: SpotifyAPI) : SpotifyEndpoint(api) {
      */
     fun add(type: LibraryType, vararg ids: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
-            put(EndpointBuilder("/me/$type").with("ids", ids.joinToString(",") { it.encode() }).toString())
+            put(EndpointBuilder("/me/$type").with("ids", ids.joinToString(",") { type.id(it).encode() }).toString())
             Unit
         })
     }
@@ -98,14 +98,14 @@ class ClientLibraryAPI(api: SpotifyAPI) : SpotifyEndpoint(api) {
      */
     fun remove(type: LibraryType, vararg ids: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
-            delete(EndpointBuilder("/me/$type").with("ids", ids.joinToString(",") { it.encode() }).toString())
+            delete(EndpointBuilder("/me/$type").with("ids", ids.joinToString(",") { type.id(it).encode() }).toString())
             Unit
         })
     }
 }
 
-enum class LibraryType(private val value: String) {
-    TRACK("tracks"), ALBUM("albums");
+enum class LibraryType(private val value: String, internal val id: (String) -> String) {
+    TRACK("tracks", { TrackURI(it).id }), ALBUM("albums", { AlbumURI(it).id });
 
     override fun toString() = value
-}
+}

src/main/kotlin/com/adamratzman/spotify/endpoints/client/ClientPlayerAPI.kt

@@ -102,20 +102,20 @@ class ClientPlayerAPI(api: SpotifyAPI) : SpotifyEndpoint(api) {
      *
      * @throws BadRequestException if more than one type of play type is specified or the offset is illegal.
      */
-    fun startPlayback(albumId: String? = null, artistId: String? = null, playlist: PlaylistParams? = null,
+    fun startPlayback(album: String? = null, artist: String? = null, playlist: PlaylistURI? = null,
                       offsetNum: Int? = null, offsetTrackId: String? = null, deviceId: String? = null, vararg tracksToPlay: String): SpotifyRestAction<Unit> {
         return toAction(Supplier {
             val url = EndpointBuilder("/me/player/play").with("device_id", deviceId).toString()
             val body = JSONObject()
             when {
-                albumId != null -> body.put("context_uri", "spotify:album:$albumId")
-                artistId != null -> body.put("context_uri", "spotify:artist:$artistId")
-                playlist != null -> body.put("context_uri", "spotify:user:${playlist.author}:playlist:${playlist.id}")
-                tracksToPlay.isNotEmpty() -> body.put("uris", tracksToPlay.map { "spotify:track:$it" })
+                album != null -> body.put("context_uri", AlbumURI(album).uri)
+                artist != null -> body.put("context_uri", ArtistURI(artist).uri)
+                playlist != null -> body.put("context_uri", playlist.uri)
+                tracksToPlay.isNotEmpty() -> body.put("uris", tracksToPlay.map { TrackURI(it).uri })
             }
             if (body.keySet().isNotEmpty()) {
                 if (offsetNum != null) body.put("offset", JSONObject().put("position", offsetNum))
-                else if (offsetTrackId != null) body.put("offset", JSONObject().put("uri", "spotify:track:$offsetTrackId"))
+                else if (offsetTrackId != null) body.put("offset", JSONObject().put("uri", TrackURI(offsetTrackId).uri))
                 put(url, body.toString())
             } else put(url)
             Unit
@@ -146,4 +146,4 @@ class ClientPlayerAPI(api: SpotifyAPI) : SpotifyEndpoint(api) {
     }
 
     enum class PlayerRepeatState { TRACK, CONTEXT, OFF }
-}
+}