Merge pull request #37 from adamint/molikuner-dev

adamint · web-flow · commit 55eb953c7f55 · 2018-12-30T21:08:24.000-05:00
Molikuner dev
diff --git a/build.gradle b/build.gradle
@@ -21,7 +21,6 @@ repositories {
 dependencies {
     // Actual library dependencies
     implementation(group: 'org.json', name: 'json', version: '20180130')
-    implementation('org.jsoup:jsoup:1.10.3')
     implementation("com.google.code.gson:gson:2.8.1")
 
     compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.3.11"
diff --git a/src/main/kotlin/com/adamratzman/spotify/main/SpotifyAPI.kt b/src/main/kotlin/com/adamratzman/spotify/main/SpotifyAPI.kt
@@ -15,13 +15,15 @@ import com.adamratzman.spotify.endpoints.public.PlaylistsAPI
 import com.adamratzman.spotify.endpoints.public.SearchAPI
 import com.adamratzman.spotify.endpoints.public.TracksAPI
 import com.adamratzman.spotify.endpoints.public.UserAPI
+import com.adamratzman.spotify.utils.HttpConnection
+import com.adamratzman.spotify.utils.HttpHeader
+import com.adamratzman.spotify.utils.HttpRequestMethod
 import com.adamratzman.spotify.utils.SpotifyEndpoint
 import com.adamratzman.spotify.utils.Token
 import com.adamratzman.spotify.utils.byteEncode
 import com.adamratzman.spotify.utils.toObject
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
-import org.jsoup.Jsoup
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 
@@ -36,26 +38,17 @@ class SpotifyApiBuilderJava(val clientId: String, val clientSecret: String) {
     var authorizationCode: String? = null
     var tokenString: String? = null
     var token: Token? = null
+    var useCache: Boolean = true
 
-    fun redirectUri(redirectUri: String?): SpotifyApiBuilderJava {
-        this.redirectUri = redirectUri
-        return this
-    }
+    fun useCache(useCache: Boolean) = apply { this.useCache = useCache }
 
-    fun authorizationCode(authorizationCode: String?): SpotifyApiBuilderJava {
-        this.authorizationCode = authorizationCode
-        return this
-    }
+    fun redirectUri(redirectUri: String?) = apply { this.redirectUri = redirectUri }
 
-    fun tokenString(tokenString: String?): SpotifyApiBuilderJava {
-        this.tokenString = tokenString
-        return this
-    }
+    fun authorizationCode(authorizationCode: String?) = apply { this.authorizationCode = authorizationCode }
 
-    fun token(token: Token?): SpotifyApiBuilderJava {
-        this.token = token
-        return this
-    }
+    fun tokenString(tokenString: String?) = apply { this.tokenString = tokenString }
+
+    fun token(token: Token?) = apply { this.token = token }
 
     fun buildCredentialed() = spotifyApi {
         credentials {
@@ -118,6 +111,7 @@ class SpotifyUserAuthorizationBuilder(
 class SpotifyApiBuilder {
     private var credentials: SpotifyCredentials = SpotifyCredentials(null, null, null)
     private var authentication = SpotifyUserAuthorizationBuilder()
+    var useCache: Boolean = true
 
     fun credentials(block: SpotifyCredentialsBuilder.() -> Unit) {
         credentials = SpotifyCredentialsBuilder().apply(block).build()
@@ -138,6 +132,8 @@ class SpotifyApiBuilder {
         return getAuthUrlFull(*scopes, clientId = credentials.clientId!!, redirectUri = credentials.redirectUri!!)
     }
 
+    fun buildCredentialedAsync(consumer: (SpotifyAPI) -> Unit) = Runnable { consumer(buildCredentialed()) }.run()
+
     fun buildCredentialed(): SpotifyAPI {
         val clientId = credentials.clientId
         val clientSecret = credentials.clientSecret
@@ -146,7 +142,7 @@ class SpotifyApiBuilder {
         }
         return when {
             authentication.token != null -> {
-                SpotifyAppAPI(clientId ?: "not-set", clientSecret ?: "not-set", authentication.token!!)
+                SpotifyAppAPI(clientId ?: "not-set", clientSecret ?: "not-set", authentication.token!!, useCache)
             }
             authentication.tokenString != null -> {
                 SpotifyAppAPI(
@@ -155,27 +151,24 @@ class SpotifyApiBuilder {
                     Token(
                         authentication.tokenString!!, "client_credentials",
                         60000, null, null
-                    )
+                    ),
+                    useCache
                 )
             }
             else -> try {
-                val token = Gson().fromJson(
-                    Jsoup.connect("https://accounts.spotify.com/api/token")
-                        .data("grant_type", "client_credentials")
-                        .header("Authorization", "Basic " + ("$clientId:$clientSecret".byteEncode()))
-                        .ignoreContentType(true).post().body().text(), Token::class.java
-                ) ?: throw IllegalArgumentException("Invalid credentials provided")
-                SpotifyAppAPI(
-                    clientId ?: throw IllegalArgumentException(),
-                    clientSecret ?: throw IllegalArgumentException(),
-                    token
-                )
+                if (clientId == null || clientSecret == null) throw IllegalArgumentException("Illegal credentials provided")
+                val token = getCredentialedToken(clientId, clientSecret)
+                    ?: throw IllegalArgumentException("Invalid credentials provided")
+                SpotifyAppAPI(clientId, clientSecret, token, useCache)
             } catch (e: Exception) {
                 throw SpotifyException("Invalid credentials provided in the login process", e)
             }
         }
     }
 
+    fun buildClientAsync(consumer: (SpotifyClientAPI) -> Unit, automaticRefresh: Boolean = false) =
+        Runnable { consumer(buildClient(automaticRefresh)) }.run()
+
     fun buildClient(automaticRefresh: Boolean = false): SpotifyClientAPI =
         buildClient(
             authentication.authorizationCode, authentication.tokenString,
@@ -210,14 +203,20 @@ class SpotifyApiBuilder {
                 SpotifyClientAPI(
                     clientId ?: throw IllegalArgumentException(),
                     clientSecret ?: throw IllegalArgumentException(),
-                    Jsoup.connect("https://accounts.spotify.com/api/token")
-                        .data("grant_type", "authorization_code")
-                        .data("code", authorizationCode)
-                        .data("redirect_uri", redirectUri)
-                        .header("Authorization", "Basic " + ("$clientId:$clientSecret").byteEncode())
-                        .ignoreContentType(true).post().body().text().toObject(Gson(), Token::class.java),
+                    HttpConnection(
+                        url = "https://accounts.spotify.com/api/token",
+                        method = HttpRequestMethod.POST,
+                        body = "grant_type=authorization_code&code=$authorizationCode&redirect_uri=$redirectUri",
+                        contentType = "application/x-www-form-urlencoded"
+                    ).execute(
+                        HttpHeader(
+                            "Authorization",
+                            "Basic ${"$clientId:$clientSecret".byteEncode()}"
+                        )
+                    ).body.toObject(Gson(), Token::class.java),
                     automaticRefresh,
-                    redirectUri ?: throw IllegalArgumentException()
+                    redirectUri ?: throw IllegalArgumentException(),
+                    useCache
                 )
             } catch (e: Exception) {
                 throw SpotifyException("Invalid credentials provided in the login process", e)
@@ -227,13 +226,15 @@ class SpotifyApiBuilder {
                 clientSecret ?: "not-set",
                 token,
                 automaticRefresh,
-                redirectUri ?: "not-set"
+                redirectUri ?: "not-set",
+                useCache
             )
             tokenString != null -> SpotifyClientAPI(
                 clientId ?: "not-set", clientSecret ?: "not-set", Token(
                     tokenString, "client_credentials", 1000,
                     null, null
-                ), false, redirectUri ?: "not-set"
+                ), false, redirectUri ?: "not-set",
+                useCache
             )
             else -> throw IllegalArgumentException(
                 "At least one of: authorizationCode, tokenString, or token must be provided " +
@@ -243,7 +244,10 @@ class SpotifyApiBuilder {
     }
 }
 
-abstract class SpotifyAPI internal constructor(val clientId: String, val clientSecret: String, var token: Token) {
+abstract class SpotifyAPI internal constructor(
+    val clientId: String, val clientSecret: String,
+    var token: Token, var useCache: Boolean
+) {
     internal var expireTime = System.currentTimeMillis() + token.expires_in * 1000
     internal val executor = Executors.newScheduledThreadPool(2)
     internal val gson = GsonBuilder().setLenient().create()!!
@@ -262,8 +266,6 @@ abstract class SpotifyAPI internal constructor(val clientId: String, val clientS
     abstract fun refreshToken()
     abstract fun clearCache()
 
-    var useCache: Boolean = true
-
     init {
         executor.scheduleAtFixedRate(::clearCache, 10, 10, TimeUnit.MINUTES)
     }
@@ -281,8 +283,8 @@ abstract class SpotifyAPI internal constructor(val clientId: String, val clientS
     }
 }
 
-class SpotifyAppAPI internal constructor(clientId: String, clientSecret: String, token: Token) :
-    SpotifyAPI(clientId, clientSecret, token) {
+class SpotifyAppAPI internal constructor(clientId: String, clientSecret: String, token: Token, useCache: Boolean) :
+    SpotifyAPI(clientId, clientSecret, token, useCache) {
     override val search: SearchAPI = SearchAPI(this)
     override val albums: AlbumAPI = AlbumAPI(this)
     override val browse: BrowseAPI = BrowseAPI(this)
@@ -300,12 +302,7 @@ class SpotifyAppAPI internal constructor(clientId: String, clientSecret: String,
 
     override fun refreshToken() {
         if (clientId != "not-set" && clientSecret != "not-set")
-            token = gson.fromJson(
-                Jsoup.connect("https://accounts.spotify.com/api/token")
-                    .data("grant_type", "client_credentials")
-                    .header("Authorization", "Basic " + ("$clientId:$clientSecret".byteEncode()))
-                    .ignoreContentType(true).post().body().text(), Token::class.java
-            )
+            token = getCredentialedToken(clientId, clientSecret)
         expireTime = System.currentTimeMillis() + token.expires_in * 1000
     }
 
@@ -326,8 +323,9 @@ class SpotifyClientAPI internal constructor(
     clientSecret: String,
     token: Token,
     automaticRefresh: Boolean = false,
-    var redirectUri: String
-) : SpotifyAPI(clientId, clientSecret, token) {
+    var redirectUri: String,
+    useCache: Boolean
+) : SpotifyAPI(clientId, clientSecret, token, useCache) {
     override val search: SearchAPI = SearchAPI(this)
     override val albums: AlbumAPI = AlbumAPI(this)
     override val browse: BrowseAPI = BrowseAPI(this)
@@ -372,11 +370,13 @@ class SpotifyClientAPI internal constructor(
 
     override fun refreshToken() {
         val tempToken = gson.fromJson(
-            Jsoup.connect("https://accounts.spotify.com/api/token")
-                .data("grant_type", "refresh_token")
-                .data("refresh_token", token.refresh_token ?: "")
-                .header("Authorization", "Basic " + ("$clientId:$clientSecret").byteEncode())
-                .ignoreContentType(true).post().body().text(), Token::class.java
+            HttpConnection(
+                url = "https://accounts.spotify.com/api/token",
+                method = HttpRequestMethod.POST,
+                body = "grant_type=refresh_token&refresh_token=${token.refresh_token ?: ""}",
+                contentType = "application/x-www-form-urlencoded"
+            ).execute(HttpHeader("Authorization", "Basic ${"$clientId:$clientSecret".byteEncode()}")).body,
+            Token::class.java
         )
         if (tempToken == null) {
             logger.logWarning("Spotify token refresh failed")
@@ -411,3 +411,13 @@ private fun getAuthUrlFull(vararg scopes: SpotifyScope, clientId: String, redire
         "&redirect_uri=$redirectUri" +
         if (scopes.isEmpty()) "" else "&scope=${scopes.joinToString("%20") { it.uri }}"
 }
+
+private fun getCredentialedToken(clientId: String, clientSecret: String) = Gson().fromJson(
+    HttpConnection(
+        url = "https://accounts.spotify.com/api/token",
+        method = HttpRequestMethod.POST,
+        body = "grant_type=client_credentials",
+        contentType = "application/x-www-form-urlencoded"
+    ).execute(HttpHeader("Authorization", "Basic ${"$clientId:$clientSecret".byteEncode()}")).body,
+    Token::class.java
+)
diff --git a/src/main/kotlin/com/adamratzman/spotify/utils/Endpoints.kt b/src/main/kotlin/com/adamratzman/spotify/utils/Endpoints.kt
@@ -13,19 +13,19 @@ import java.util.function.Supplier
 abstract class SpotifyEndpoint(val api: SpotifyAPI) {
     internal val cache = SpotifyCache()
 
-    fun get(url: String): String {
+    internal fun get(url: String): String {
         return execute(url)
     }
 
-    fun post(url: String, body: String? = null): String {
+    internal fun post(url: String, body: String? = null): String {
         return execute(url, body, HttpRequestMethod.POST)
     }
 
-    fun put(url: String, body: String? = null, contentType: String? = null): String {
+    internal fun put(url: String, body: String? = null, contentType: String? = null): String {
         return execute(url, body, HttpRequestMethod.PUT, contentType = contentType)
     }
 
-    fun delete(
+    internal fun delete(
         url: String,
         body: String? = null,
         contentType: String? = null
@@ -50,9 +50,11 @@ abstract class SpotifyEndpoint(val api: SpotifyAPI) {
             cache -= spotifyRequest
         }
 
-        val document = createConnection(url, body, method, contentType).apply {
-            if (cacheState?.eTag != null) headers.add(HttpHeader("If-None-Match", cacheState.eTag))
-        }.execute()
+        val document = createConnection(url, body, method, contentType).execute(
+            cacheState?.eTag?.let {
+                HttpHeader("If-None-Match", it)
+            }
+        )
 
         return handleResponse(document, cacheState, spotifyRequest, retry202) ?: execute(
             url,
diff --git a/src/main/kotlin/com/adamratzman/spotify/utils/HttpConnection.kt b/src/main/kotlin/com/adamratzman/spotify/utils/HttpConnection.kt
@@ -3,49 +3,44 @@ package com.adamratzman.spotify.utils
 import java.net.HttpURLConnection
 import java.net.URL
 
-enum class HttpRequestMethod { GET, POST, PUT, DELETE, }
+enum class HttpRequestMethod { GET, POST, PUT, DELETE }
 data class HttpHeader(val key: String, val value: String)
 
 class HttpConnection(
     private val url: String,
     private val method: HttpRequestMethod,
     private val body: String?,
     private val contentType: String?,
-    vararg headersVararg: HttpHeader,
-    val headers: MutableList<HttpHeader> = headersVararg.toMutableList()
+    private vararg val headers: HttpHeader
 ) {
 
-    fun execute(): HttpResponse {
+    fun execute(vararg additionalHeaders: HttpHeader?): HttpResponse {
         val connection = URL(url).openConnection() as HttpURLConnection
         connection.requestMethod = method.toString()
 
         contentType?.let { connection.setRequestProperty("Content-Type", contentType) }
-        headers.forEach { (key, value) -> connection.setRequestProperty(key, value) }
-
-        if (body != null || method != HttpRequestMethod.GET){
-            connection.doOutput = true
-            connection.setFixedLengthStreamingMode(body?.length ?: 0)
+        headers.union(additionalHeaders.filterNotNull()).forEach { (key, value) ->
+            connection.setRequestProperty(key, value)
         }
 
-        body?.let { _ ->
-            connection.outputStream.bufferedWriter().also { it.write(body) }.let { it.close() }
+        if (body != null || method != HttpRequestMethod.GET) {
+            connection.doOutput = true
+            connection.setFixedLengthStreamingMode(body?.toByteArray()?.size ?: 0)
+            connection.outputStream.bufferedWriter().use {
+                body?.also(it::write)
+            }
         }
 
         connection.connect()
 
-        val responseCode = connection.responseCode
-
-        val outputBody = (connection.errorStream ?: connection.inputStream).bufferedReader().let {
-            val text = it.readText()
-            it.close()
-            text
-        }
-
-        val headers = connection.headerFields.keys.filterNotNull().map { HttpHeader(it, connection.getHeaderField(it)) }
-        connection.disconnect()
-
-        return HttpResponse(responseCode, outputBody, headers)
+        return HttpResponse(
+            responseCode = connection.responseCode,
+            body = (connection.errorStream ?: connection.inputStream).bufferedReader().use {
+                it.readText()
+            },
+            headers = connection.headerFields.keys.filterNotNull().map { HttpHeader(it, connection.getHeaderField(it)) }
+        ).also { connection.disconnect() }
     }
 }
 
-data class HttpResponse(val responseCode: Int, val body: String, val headers: List<HttpHeader>)
+data class HttpResponse(val responseCode: Int, val body: String, val headers: List<HttpHeader>)
diff --git a/src/test/kotlin/com/adamratzman/spotify/utilities/HttpConnectionTests.kt b/src/test/kotlin/com/adamratzman/spotify/utilities/HttpConnectionTests.kt
diff --git a/src/test/kotlin/com/adamratzman/spotify/utilities/UtilityTests.kt b/src/test/kotlin/com/adamratzman/spotify/utilities/UtilityTests.kt
