fix cursor-based paging object multi-retrieval, old uris, update samples

Author: adamint

samples/src/main/kotlin/private/ClientFollowingApiSample.kt

@@ -2,7 +2,9 @@
 package private
 
 import com.adamratzman.spotify.SpotifyApi.Companion.spotifyClientApi
+import com.adamratzman.spotify.annotations.SpotifyExperimentalHttpApi
 
+@SpotifyExperimentalHttpApi
 fun main() {
     // instantiate api
     val api = spotifyClientApi(
@@ -24,7 +26,7 @@ fun main() {
     println(api.following.isFollowingArtist("spotify:artist:7wjeXCtRND2ZdKfMJFu6JC").complete())
 
     // get all followed artists, limiting 1 each request
-    println(api.following.getFollowedArtists(limit = 1).getAllItems().complete().map { it.name })
+    println(api.following.getFollowedArtists(limit = 1).getAllItems().complete())
 
     // follow and unfollow, if you weren't previously following, the artist Louane
 
@@ -37,12 +39,12 @@ fun main() {
 
     // follow and unfollow, if you weren't previously following, the user adamratzman1
 
-    val isFollowingAdam = api.following.isFollowingUser("adamratzman1").complete()
+    val isFollowingAdam = api.following.isFollowingUser("adamratzman").complete()
 
-    if (isFollowingAdam) api.following.unfollowUser("adamratzman1").complete()
-    api.following.followUser("adamratzman1").complete()
+    if (isFollowingAdam) api.following.unfollowUser("adamratzman").complete()
+    api.following.followUser("adamratzman").complete()
 
-    if (!isFollowingAdam) api.following.unfollowUser("adamratzman1").complete()
+    if (!isFollowingAdam) api.following.unfollowUser("adamratzman").complete()
 
     // follow and unfollow, if you weren't previously following, the playlist Today's Top Hits
 

samples/src/main/kotlin/private/ClientPlayerApiSample.kt

@@ -29,12 +29,18 @@ fun main() {
     // get the currenty played PlaybackActions
     println(api.player.getCurrentlyPlaying().complete()?.actions)
 
-    // pause playback on the current device
+    // play song "I'm Good" by the Mowgli's
+    api.player.startPlayback(tracksToPlay = listOf(api.search.searchTrack("I'm Good the Mowgli's").complete()[0].uri.uri)).complete()
+
+    // pause playback on the current device.
     api.player.pause().complete()
 
     // seek the beginning of the track currently playing
     api.player.seek(0).complete()
 
+    // resume playback
+    api.player.resume().complete()
+
     // set repeat the current track
     api.player.setRepeatMode(TRACK).complete()
 
@@ -47,15 +53,9 @@ fun main() {
     // skip back to the last track that was in the user queue
     api.player.skipBehind().complete()
 
-    // resume playback
-    api.player.resume().complete()
-
-    // play song "I'm Good" by the Mowgli's
-    api.player.startPlayback(tracksToPlay = listOf(api.search.searchTrack("I'm Good the Mowgli's").complete()[0].uri.uri)).complete()
-
     // toggle shuffling
     api.player.toggleShuffle(shuffle = true).complete()
 
     // transfer playback
-    api.player.transferPlayback("your_device_id").complete()
+    api.player.transferPlayback(api.player.getDevices().complete().first().id!!).complete()
 }

samples/src/main/kotlin/private/ClientPlaylistApiSample.kt

@@ -39,7 +39,7 @@ fun main() {
     // for an example of re-ordering tracks
 
     // replace the tracks in a client playlist with two songs by Lorde
-    api.playlists.setClientPlaylistTracks(playlist.id, "spotify:track:6ie2Bw3xLj2JcGowOlcMhb", "").complete()
+    api.playlists.setClientPlaylistTracks(playlist.id, "spotify:track:6ie2Bw3xLj2JcGowOlcMhb", "spotify:track:2dLLR6qlu5UJ5gk0dKz0h3").complete()
 
     // remove the song we just added from our client playlist
     api.playlists.removeTrackFromClientPlaylist(playlist.id, "spotify:track:6ie2Bw3xLj2JcGowOlcMhb").complete()

src/commonMain/kotlin/com.adamratzman.spotify/SpotifyExceptions.kt

@@ -11,26 +11,29 @@ sealed class SpotifyException(message: String, cause: Throwable? = null) : Excep
     /**
      * Thrown when a request fails
      */
-    open class BadRequestException(message: String, val statusCode: Int? = null, cause: Throwable? = null) :
-        SpotifyException(message, cause) {
-        constructor(message: String, cause: Throwable? = null) : this(message, null, cause)
+    open class BadRequestException(message: String, val statusCode: Int? = null, val reason: String? = null, cause: Throwable? = null) :
+            SpotifyException(message, cause) {
+        constructor(message: String, cause: Throwable? = null) : this(message, null, null, cause)
         constructor(error: ErrorObject, cause: Throwable? = null) : this(
-            "Received Status Code ${error.status}. Error cause: ${error.message}",
-            error.status,
-            cause
+                "Received Status Code ${error.status}. Error cause: ${error.message}" + (error.reason?.let { ". Reason: ${error.reason}" }
+                        ?: ""),
+                error.status,
+                error.reason,
+                cause
         )
 
         constructor(authenticationError: AuthenticationError) :
                 this(
-                    "Authentication error: ${authenticationError.error}. Description: ${authenticationError.description}",
-                    401
+                        "Authentication error: ${authenticationError.error}. Description: ${authenticationError.description}",
+                        401
                 )
 
         constructor(responseException: ResponseException) :
                 this(
-                    responseException.message ?: "Bad Request",
-                    responseException.response.status.value,
-                    responseException
+                        responseException.message ?: "Bad Request",
+                        responseException.response.status.value,
+                        null,
+                        responseException
                 )
     }
 

src/commonMain/kotlin/com.adamratzman.spotify/http/HttpConnection.kt

@@ -3,7 +3,10 @@ package com.adamratzman.spotify.http
 
 import com.adamratzman.spotify.SpotifyApi
 import com.adamratzman.spotify.SpotifyException
+import com.adamratzman.spotify.models.ErrorResponse
 import com.adamratzman.spotify.models.SpotifyRatelimitedException
+import com.adamratzman.spotify.models.serialization.stableJson
+import com.adamratzman.spotify.models.serialization.toObject
 import com.adamratzman.spotify.utils.getCurrentTimeMs
 import io.ktor.client.HttpClient
 import io.ktor.client.features.ResponseException
@@ -144,7 +147,9 @@ class HttpConnection constructor(
         } catch (e: CancellationException) {
             throw e
         } catch (e: ResponseException) {
-            throw SpotifyException.BadRequestException(e)
+            val errorBody = e.response.readText()
+            val error = errorBody.toObject(ErrorResponse.serializer(), api, api?.json ?: stableJson).error
+            throw SpotifyException.BadRequestException(error)
         }
     }
 

src/commonMain/kotlin/com.adamratzman.spotify/models/PagingObjects.kt

@@ -76,15 +76,15 @@ class PagingObject<T : Any>(
         val endpointFinal = endpoint!!
         return (if (type == FORWARDS) next else previous)?.let { endpoint!!.get(it) }?.let { json ->
             when (itemClazz) {
-                SimpleTrack::class -> json.toPagingObject(SimpleTrack.serializer(), null, endpointFinal, endpointFinal.api.json)
-                SpotifyCategory::class -> json.toPagingObject(SpotifyCategory.serializer(), "categories", endpointFinal, endpointFinal.api.json)
-                SimpleAlbum::class -> json.toPagingObject(SimpleAlbum.serializer(), "albums", endpointFinal, endpointFinal.api.json)
-                SimplePlaylist::class -> json.toPagingObject(SimplePlaylist.serializer(), "playlists", endpointFinal, endpointFinal.api.json)
-                SavedTrack::class -> json.toPagingObject(SavedTrack.serializer(), null, endpointFinal, endpointFinal.api.json)
-                SavedAlbum::class -> json.toPagingObject(SavedAlbum.serializer(), null, endpointFinal, endpointFinal.api.json)
-                Artist::class -> json.toPagingObject(Artist.serializer(), null, endpointFinal, endpointFinal.api.json)
-                Track::class -> json.toPagingObject(Track.serializer(), null, endpointFinal, endpointFinal.api.json)
-                PlaylistTrack::class -> json.toPagingObject(PlaylistTrack.serializer(), null, endpointFinal, endpointFinal.api.json)
+                SimpleTrack::class -> json.toPagingObject(SimpleTrack.serializer(), null, endpointFinal, endpointFinal.api.json, true)
+                SpotifyCategory::class -> json.toPagingObject(SpotifyCategory.serializer(), "categories", endpointFinal, endpointFinal.api.json, true)
+                SimpleAlbum::class -> json.toPagingObject(SimpleAlbum.serializer(), "albums", endpointFinal, endpointFinal.api.json, true)
+                SimplePlaylist::class -> json.toPagingObject(SimplePlaylist.serializer(), "playlists", endpointFinal, endpointFinal.api.json, true)
+                SavedTrack::class -> json.toPagingObject(SavedTrack.serializer(), null, endpointFinal, endpointFinal.api.json, true)
+                SavedAlbum::class -> json.toPagingObject(SavedAlbum.serializer(), null, endpointFinal, endpointFinal.api.json, true)
+                Artist::class -> json.toPagingObject(Artist.serializer(), null, endpointFinal, endpointFinal.api.json, true)
+                Track::class -> json.toPagingObject(Track.serializer(), null, endpointFinal, endpointFinal.api.json, true)
+                PlaylistTrack::class -> json.toPagingObject(PlaylistTrack.serializer(), null, endpointFinal, endpointFinal.api.json, true)
                 else -> throw IllegalArgumentException("Unknown type in $href response")
             } as? PagingObject<T>
         }

src/commonMain/kotlin/com.adamratzman.spotify/models/Player.kt

@@ -54,7 +54,7 @@ data class Device(
     @SerialName("is_private_session") val isPrivateSession: Boolean,
     @SerialName("is_restricted") val isRestricted: Boolean,
     val name: String,
-    val typeString: String,
+    @SerialName("type") val typeString: String,
     @SerialName("volume_percent") val volumePercent: Int
 ) : IdentifiableNullable() {
     @Transient
@@ -106,7 +106,7 @@ data class CurrentlyPlayingContext(
     @SerialName("item") val track: Track? = null,
     @SerialName("shuffle_state") val shuffleState: Boolean,
     @SerialName("repeat_state") val repeatStateString: String,
-    val context: Context
+    val context: Context? = null
 ) {
     @Transient
     val repeatState: RepeatState = RepeatState.values().match(repeatStateString)!!

src/commonMain/kotlin/com.adamratzman.spotify/models/ResultObjects.kt

@@ -109,7 +109,7 @@ data class ErrorResponse(val error: ErrorObject, @Transient val exception: Excep
  * @property message A short description of the cause of the error.
  */
 @Serializable
-data class ErrorObject(val status: Int, val message: String)
+data class ErrorObject(val status: Int, val message: String, val reason: String? = null)
 
 /**
  * An exception during the authentication process

src/commonMain/kotlin/com.adamratzman.spotify/models/SpotifyUris.kt

@@ -41,6 +41,13 @@ private class SimpleUriSerializer<T : SpotifyUri>(val ctor: (String) -> T) : KSe
     override fun serialize(encoder: Encoder, obj: T) = encoder.encodeString(obj.uri)
 }
 
+@PublishedApi
+internal fun fixSpotifyUri(uri: String): String {
+    val matchesOldPlaylistUriFormat = "^spotify:user:(?:.*:)*playlist:(.+)\$".toRegex().matchEntire(uri)
+    return (matchesOldPlaylistUriFormat?.let { result -> "spotify:playlist:${result.groupValues[1]}" } ?: uri)
+            .replace(" ", "")
+}
+
 /**
  * Represents a Spotify URI, parsed from either a Spotify ID or taken from an endpoint.
  *
@@ -53,7 +60,7 @@ sealed class SpotifyUri(input: String, type: String) {
     val id: String
 
     init {
-        input.replace(" ", "").let {
+        fixSpotifyUri(input).let {
             this.uri = it.add(type)
             this.id = it.remove(type)
         }
@@ -71,7 +78,7 @@ sealed class SpotifyUri(input: String, type: String) {
     }
 
     override fun toString(): String {
-        return "SpotifyUri($uri)"
+        return "SpotifyUri(${fixSpotifyUri(uri)})"
     }
 
     @Serializer(forClass = SpotifyUri::class)
@@ -85,7 +92,7 @@ sealed class SpotifyUri(input: String, type: String) {
          * */
         inline fun <T : SpotifyUri> safeInitiate(uri: String, ctor: (String) -> T): T? {
             return try {
-                ctor(uri)
+                ctor(fixSpotifyUri(uri))
             } catch (e: SpotifyUriException) {
                 null
             }
@@ -94,7 +101,8 @@ sealed class SpotifyUri(input: String, type: String) {
         /**
          * Creates a abstract SpotifyUri of given input. Doesn't allow ambiguity by disallowing creation by id.
          * */
-        operator fun invoke(input: String): SpotifyUri {
+        operator fun invoke(inputTemp: String): SpotifyUri {
+            val input = fixSpotifyUri(inputTemp)
             val constructors = listOf(::AlbumUri, ::ArtistUri, TrackUri.Companion::invoke, ::UserUri, ::PlaylistUri)
             for (ctor in constructors) {
                 safeInitiate(input, ctor)?.takeIf { it.uri == input }?.also { return it }
@@ -112,7 +120,8 @@ sealed class SpotifyUri(input: String, type: String) {
          *     SpotifyUri.isType<UserUri>("spotify:track:abc") // returns: false
          * ```
          * */
-        inline fun <reified T : SpotifyUri> isType(input: String): Boolean {
+        inline fun <reified T : SpotifyUri> isType(inputTemp: String): Boolean {
+            val input = fixSpotifyUri(inputTemp)
             return safeInitiate(input, ::invoke)?.let { it is T } ?: false
         }
 
@@ -125,7 +134,8 @@ sealed class SpotifyUri(input: String, type: String) {
          *     SpotifyUri.canBeType<UserUri>("spotify:track:abc") // returns: false
          * ```
          * */
-        inline fun <reified T : SpotifyUri> canBeType(input: String): Boolean {
+        inline fun <reified T : SpotifyUri> canBeType(inputTemp: String): Boolean {
+            val input = fixSpotifyUri(inputTemp)
             return isType<T>(input) || !input.contains(':')
         }
     }

src/commonMain/kotlin/com.adamratzman.spotify/models/serialization/SerializationUtils.kt

@@ -59,9 +59,10 @@ internal fun <T : Any> String.toPagingObject(
     innerObjectName: String? = null,
     endpoint: SpotifyEndpoint,
     json: Json,
-    arbitraryInnerNameAllowed: Boolean = false
+    arbitraryInnerNameAllowed: Boolean = false,
+    skipInnerNameFirstIfPossible: Boolean = true
 ): PagingObject<T> {
-    if (innerObjectName != null || arbitraryInnerNameAllowed) {
+    if (innerObjectName != null || (arbitraryInnerNameAllowed && !skipInnerNameFirstIfPossible)) {
         val map = this.parseJson { json.parse((String.serializer() to PagingObject.serializer(tSerializer)).map, this) }
         return (map[innerObjectName] ?: if (arbitraryInnerNameAllowed) map.keys.firstOrNull()?.let { map[it] }
                 ?: error("") else error(""))
@@ -94,7 +95,8 @@ internal fun <T : Any> String.toPagingObject(
                     innerObjectName,
                     endpoint,
                     json,
-                    true
+                    true,
+                    false
             )
         } else throw jde
     }
@@ -105,41 +107,68 @@ internal inline fun <reified T : Any> String.toPagingObject(
     innerObjectName: String? = null,
     endpoint: SpotifyEndpoint,
     json: Json,
-    arbitraryInnerNameAllowed: Boolean = false
-): PagingObject<T> = toPagingObject(T::class, tSerializer, innerObjectName, endpoint, json, arbitraryInnerNameAllowed)
+    arbitraryInnerNameAllowed: Boolean = false,
+    skipInnerNameFirstIfPossible: Boolean = true
+): PagingObject<T> = toPagingObject(T::class, tSerializer, innerObjectName, endpoint, json, arbitraryInnerNameAllowed, skipInnerNameFirstIfPossible)
 
-internal inline fun <reified T : Any> String.toCursorBasedPagingObject(
+internal fun <T : Any> String.toCursorBasedPagingObject(
+    tClazz: KClass<T>,
     tSerializer: KSerializer<T>,
     innerObjectName: String? = null,
     endpoint: SpotifyEndpoint,
-    json: Json
+    json: Json,
+    arbitraryInnerNameAllowed: Boolean = false,
+    skipInnerNameFirstIfPossible: Boolean = true
 ): CursorBasedPagingObject<T> {
-    if (innerObjectName != null) {
+    if (innerObjectName != null || (arbitraryInnerNameAllowed && !skipInnerNameFirstIfPossible)) {
         val map = this.parseJson { json.parse((String.serializer() to CursorBasedPagingObject.serializer(tSerializer)).map, this) }
-
-        return (map[innerObjectName] ?: error(""))
+        return (map[innerObjectName] ?: if (arbitraryInnerNameAllowed) map.keys.firstOrNull()?.let { map[it] }
+                ?: error("") else error(""))
                 .apply {
                     this.endpoint = endpoint
-                    this.itemClazz = T::class
+                    this.itemClazz = tClazz
                     this.items.map { obj ->
                         if (obj is NeedsApi) obj.api = endpoint.api
                         if (obj is AbstractPagingObject<*>) obj.endpoint = endpoint
                     }
                 }
     }
+    return try {
+        val pagingObject = this.parseJson { json.parse(CursorBasedPagingObject.serializer(tSerializer), this) }
 
-    val pagingObject = this.parseJson { json.parse(CursorBasedPagingObject.serializer(tSerializer), this) }
-
-    return pagingObject.apply {
-        this.endpoint = endpoint
-        this.itemClazz = T::class
-        this.items.map { obj ->
-            if (obj is NeedsApi) obj.api = endpoint.api
-            if (obj is AbstractPagingObject<*>) obj.endpoint = endpoint
+        pagingObject.apply {
+            this.endpoint = endpoint
+            this.itemClazz = tClazz
+            this.items.map { obj ->
+                if (obj is NeedsApi) obj.api = endpoint.api
+                if (obj is AbstractPagingObject<*>) obj.endpoint = endpoint
+            }
         }
+    } catch (jde: SpotifyException.ParseException) {
+        if (!arbitraryInnerNameAllowed && jde.message?.contains("unable to parse", true) == true) {
+            toCursorBasedPagingObject(
+                    tClazz,
+                    tSerializer,
+                    innerObjectName,
+                    endpoint,
+                    json,
+                    arbitraryInnerNameAllowed = true,
+                    skipInnerNameFirstIfPossible = false
+            )
+        } else throw jde
     }
 }
 
+internal inline fun <reified T : Any> String.toCursorBasedPagingObject(
+    tSerializer: KSerializer<T>,
+    innerObjectName: String? = null,
+    endpoint: SpotifyEndpoint,
+    json: Json,
+    arbitraryInnerNameAllowed: Boolean = false,
+    skipInnerNameFirstIfPossible: Boolean = true
+): CursorBasedPagingObject<T> =
+        toCursorBasedPagingObject(T::class, tSerializer, innerObjectName, endpoint, json, arbitraryInnerNameAllowed, skipInnerNameFirstIfPossible)
+
 internal inline fun <reified T> String.toInnerObject(serializer: KSerializer<T>, innerName: String, json: Json): T {
     val map = this.parseJson { json.parse((String.serializer() to serializer).map, this) }
     return (map[innerName] ?: error("Inner object with name $innerName doesn't exist in $map"))