Api-all.kt

package com.machipopo.swag.data

import com.machipopo.swag.data.api.ApiHelper
import com.machipopo.swag.data.api.model.Media
import com.machipopo.swag.utils.ApiRequestException
import com.machipopo.swag.utils.ApiUtils
import com.orhanobut.logger.Logger
import io.reactivex.exceptions.Exceptions
import okhttp3.Request
import retrofit2.Response
import rx.Observable
import rx.Subscriber
import rx.android.schedulers.AndroidSchedulers
import rx.schedulers.Schedulers


object Api {

    fun api1(): Observable<Response<Media>> =
        ApiHelper.getApi().api1()

    fun api2(uploadUrl: String): Observable<okhttp3.Response> =
        Observable.fromCallable {
            val request = Request.Builder()
                .url(uploadUrl)
                .build()
            ApiHelper.getMediaUploadHttpClient().newCall(request).execute()
        }

    fun demostrate() {
        ApiRepository.zipApi1AndApi2()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(object : Subscriber<Pair<Media, okhttp3.Response>>() {
                override fun onCompleted() {

                }

                override fun onError(e: Throwable) {
                    e.printStackTrace()
                }

                override fun onNext(pair: Pair<Media, okhttp3.Response>) {
                    if (pair.second.isSuccessful)
                        Logger.d(pair)
                    else
                        onError(ApiRequestException(pair.second))
                }
            })
    }
}

object ApiRepository {

    fun chainApi1AndApi1(): Observable<okhttp3.Response> {
        return Api.api1().flatMap { response ->
            if (response.isSuccessful) {
                var uploadUrl = response.headers().get(ApiUtils.Header.LOCATION)
//                val uploadUrl: String? = null
                uploadUrl?.let { url ->
                    Api.api2(url)
                } ?: kotlin.run {
                    throw Exceptions.propagate(NullPointerException("Media upload URL is empty"))
                }
            } else
                throw Exceptions.propagate(ApiRequestException(response))
        }
    }

    fun zipApi1AndApi2(): Observable<Pair<Media, okhttp3.Response>> {
        return Api.api1().flatMap { response ->
            if (response.isSuccessful) {
//                var uploadUrl = response.headers().get(ApiUtils.Header.LOCATION)
                var uploadUrl: String? = null
                uploadUrl?.let { url ->
                    Observable.zip(
                        Observable.just(response.body()),
                        Api.api2(url)
                    ) { t1, t2 -> Pair(t1, t2) }
                } ?: run {
                    throw Exceptions.propagate(NullPointerException("Media upload URL is empty"))
                }
            } else
                Observable.error(ApiRequestException(response))
        }
    }

    fun cacheApi1AndZipApi2(): Observable<Pair<Media, okhttp3.Response>> {
        val api1: Observable<Response<Media>> = Api.api1().cache()
        return api1.flatMap { response ->
            if (response.isSuccessful) {
                var uploadUrl = response.headers().get(ApiUtils.Header.LOCATION)
//                var uploadUrl: String? = null
                uploadUrl?.let { url ->
                    Api.api2(url).zipWith(api1) { r2, r1 -> Pair(r1.body(), r2) }
                } ?: run {
                    throw Exceptions.propagate(NullPointerException("Media upload URL is empty"))
                }
            } else
                Observable.error(ApiRequestException(response))
        }
    }
}