summaryrefslogtreecommitdiff
path: root/cashier/src/main/java/net/taler/cashier/Response.kt
blob: 0ad39d0ab79dcffc31036c05651b4e9c47ca265f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
/*
 * This file is part of GNU Taler
 * (C) 2020 Taler Systems S.A.
 *
 * GNU Taler is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 3, or (at your option) any later version.
 *
 * GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */

package net.taler.cashier

import android.content.Context
import android.util.Log
import io.ktor.client.call.receive
import io.ktor.client.features.ResponseException
import io.ktor.http.HttpStatusCode
import kotlinx.serialization.Serializable
import net.taler.common.isOnline
import java.net.UnknownHostException

class Response<out T> private constructor(
    private val value: Any?
) {
    companion object {
        suspend fun <T> response(request: suspend () -> T): Response<T> {
            return try {
                Response(request())
            } catch (e: Throwable) {
                Log.e("HttpClient", "Error getting request", e)
                Response(getFailure(e))
            }
        }

        private suspend fun getFailure(e: Throwable): Failure = when (e) {
            is ResponseException -> Failure(e, getExceptionString(e), e.response?.status)
            else -> Failure(e, e.toString())
        }

        private suspend fun getExceptionString(e: ResponseException): String {
            val response = e.response ?: return e.toString()
            return try {
                Log.e("TEST", "TRY RECEIVE $response")
                val error: Error = response.receive()
                "Error ${error.code}: ${error.hint}"
            } catch (ex: Exception) {
                "Status code: ${response.status.value}"
            }
        }
    }

    private val isFailure: Boolean get() = value is Failure

    suspend fun onSuccess(block: suspend (result: T) -> Unit): Response<T> {
        @Suppress("UNCHECKED_CAST")
        if (!isFailure) block(value as T)
        return this
    }

    suspend fun onError(block: suspend (failure: Failure) -> Unit): Response<T> {
        if (value is Failure) block(value)
        return this
    }

    data class Failure(
        val exception: Throwable,
        val msg: String,
        val statusCode: HttpStatusCode? = null
    ) {
        fun isOffline(context: Context): Boolean {
            return exception is UnknownHostException && !context.isOnline()
        }
    }

    @Serializable
    private class Error(
        val code: Int?,
        val hint: String?
    )
}