SoftKashNetworkDataSourceImpl.kt

class SoftKashNetworkDataSourceImpl(
    private val softKashApiService: SoftKashApiService
) : SoftKashNetworkDataSource {
    private val _getAllAdmins = MutableLiveData<GetAdminResponse>()

    override val getAllAdmins: LiveData<GetAdminResponse>
        get() = _getAllAdmins

    override suspend fun fetchAllAdmins() {
        try {
            val fetchAdmins = softKashApiService
                .getAdminsAsync()
                .await()
            _getAllAdmins.postValue(fetchAdmins)
        }catch (e: NoConnectivityException){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    private val _getLoanProducts = MutableLiveData<LoanProductResponse>()
    override val getAllLoanProducts: LiveData<LoanProductResponse>
        get() = _getLoanProducts

    override suspend fun getLoanProducts() {
       try {
           val fetchLoanProducts = softKashApiService
               .getLoanProductAsync()
               .await()
           _getLoanProducts.postValue(fetchLoanProducts)
       }catch (e: Throwable){
           Log.e("connectivity ", "{${e.localizedMessage}}", e)
       }
    }

    override suspend fun getTransactions(paginate: String, result: (Response<TransactionResponse>) -> Unit) {
        try {
            softKashApiService.getTransactionsAsync(paginate)
                .enqueue(object : Callback<TransactionResponse>{
                    override fun onResponse(
                        call: Call<TransactionResponse>,
                        response: Response<TransactionResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<TransactionResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getLoans(paginate: String, result: (Response<LoansResponse>) -> Unit) {
        try {
           softKashApiService.getLoansAsync(paginate)
               .enqueue(object : Callback<LoansResponse>{
                   override fun onResponse(
                       call: Call<LoansResponse>,
                       response: Response<LoansResponse>
                   ) {
                      result(response)
                   }

                   override fun onFailure(call: Call<LoansResponse>, t: Throwable) {
                       Log.e("Error", "Network error")
                   }
               })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }


    override suspend fun nextOfKinDetail(userId: Int, result: ( Response<NestOfKinResponse>) -> Unit ) {
        try {
                     softKashApiService
                    .getUserNextOfKinAsync(userId)
                    .enqueue(object : Callback<NestOfKinResponse>{
                        override fun onResponse(call: Call<NestOfKinResponse>, response: Response<NestOfKinResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<NestOfKinResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })

        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun employerDetail(userId: Int, result: (Response<EmployerResponse>) -> Unit) {
        try {
            softKashApiService
                    .getUserEmployerDetailAsync(userId)
                    .enqueue(object : Callback<EmployerResponse>{
                        override fun onResponse(call: Call<EmployerResponse>, response: Response<EmployerResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<EmployerResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun deleteDocuments(
        id: Int,
        result: (Response<DocumentDeleteResponse>) -> Unit
    ) {
        try {
            softKashApiService
                .deleteDocuments(id)
                .enqueue(object : Callback<DocumentDeleteResponse>{
                    override fun onResponse(
                        call: Call<DocumentDeleteResponse>,
                        response: Response<DocumentDeleteResponse>
                    ) {
                       result(response)
                    }

                    override fun onFailure(call: Call<DocumentDeleteResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }

    }

    override suspend fun getPaymentHistory(paginate: String, result: (Response<RepaymentHistoryResponse>) -> Unit) {
        try {
            softKashApiService.getPaymentHistoryAsync(paginate)
                .enqueue(object : Callback<RepaymentHistoryResponse>{
                    override fun onResponse(
                        call: Call<RepaymentHistoryResponse>,
                        response: Response<RepaymentHistoryResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<RepaymentHistoryResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun userDetail(userId: Int, result: (Response<UserDetailsResponse>) -> Unit) {
        try {
         softKashApiService
                 .getUserDetailsAsync(userId)
                 .enqueue(object : Callback<UserDetailsResponse>{
                     override fun onResponse(call: Call<UserDetailsResponse>, response: Response<UserDetailsResponse>) {
                         result(response)
                     }

                     override fun onFailure(call: Call<UserDetailsResponse>, t: Throwable) {
                         Log.e("Error", "Network error")
                     }
                 })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getUserSpecificLoan(
        userId: Int,
        result: (Response<UserDetailLoanResponse>) -> Unit
    ) {
        try {
            softKashApiService
                .getSpecificUserLoans(userId)
                .enqueue(object : Callback<UserDetailLoanResponse>{
                    override fun onResponse(
                        call: Call<UserDetailLoanResponse>,
                        response: Response<UserDetailLoanResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<UserDetailLoanResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun addAdmins(firstName: RequestBody, lastName: RequestBody, email: RequestBody,
                                   phoneNo: RequestBody, department: RequestBody, roleName: RequestBody,
                                   staffId: RequestBody, roleId: RequestBody, password: RequestBody, result: (Response<AddAdminResponse>) -> Unit) {
        try {
            softKashApiService.addAdminsAsync(firstName, lastName, email, phoneNo, department,
                                            roleName, staffId, roleId, password)
                    .enqueue(object : Callback<AddAdminResponse>{
                        override fun onResponse(call: Call<AddAdminResponse>, response: Response<AddAdminResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<AddAdminResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getLoanByStatus(
        status: String,
        result: (Response<LoanByStatusResponse>) -> Unit
    ) {
        try {
            softKashApiService.getLoanByStatusAsync(status)
                .enqueue(object : Callback<LoanByStatusResponse>{
                    override fun onResponse(
                        call: Call<LoanByStatusResponse>,
                        response: Response<LoanByStatusResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<LoanByStatusResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getUserTransactionHistory(userId: Int, paginate: String,
                                                   result: (Response<UserTransactionResponse>) -> Unit) {
        try {
            softKashApiService.getUserTransactionHistory(userId, paginate)
                    .enqueue(object : Callback<UserTransactionResponse>{
                        override fun onResponse(call: Call<UserTransactionResponse>, response: Response<UserTransactionResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<UserTransactionResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun approveAndRejectLoan(action: RequestBody, loanId: RequestBody,
                                              adminId: RequestBody, userId: RequestBody,
                                              result: (Response<ApproveAndRejectLoanResponse>) -> Unit) {
        try {
            softKashApiService.approveAndReject(action, loanId, adminId, userId).enqueue(
                    object : Callback<ApproveAndRejectLoanResponse>{
                        override fun onResponse(call: Call<ApproveAndRejectLoanResponse>, response: Response<ApproveAndRejectLoanResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<ApproveAndRejectLoanResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    }
            )
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun disburseLoan(
        adminId: RequestBody,
        userId: RequestBody,
        loanId: RequestBody,
        result: (Response<DisburseLoanResponse>) -> Unit
    ) {
        try {
            softKashApiService.disburseLoan(adminId,userId, loanId)
                .enqueue(object : Callback<DisburseLoanResponse>{
                    override fun onResponse(
                        call: Call<DisburseLoanResponse>,
                        response: Response<DisburseLoanResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<DisburseLoanResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun login(
        email: RequestBody,
        password: RequestBody,
        result: (Response<LogInResponse>) -> Unit
    ) {
        try {
            softKashApiService.login(email, password)
                .enqueue(object : Callback<LogInResponse>{
                    override fun onResponse(
                        call: Call<LogInResponse>,
                        response: Response<LogInResponse>
                    ) {
                       result(response)
                    }

                    override fun onFailure(call: Call<LogInResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun blockAdmin(adminId: Int, result: (Response<BlockAdminResponse>) -> Unit) {
        try {
            softKashApiService.blockAdmin(adminId)
                .enqueue(object : Callback<BlockAdminResponse>{
                    override fun onResponse(
                        call: Call<BlockAdminResponse>,
                        response: Response<BlockAdminResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<BlockAdminResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun unblockAdmin(
        adminId: Int,
        result: (Response<BlockAdminResponse>) -> Unit
    ) {
        try {
            softKashApiService.unblockAdmin(adminId)
                .enqueue(object : Callback<BlockAdminResponse>{
                    override fun onResponse(
                        call: Call<BlockAdminResponse>,
                        response: Response<BlockAdminResponse>
                    ) {
                       result(response)
                    }

                    override fun onFailure(call: Call<BlockAdminResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })

        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun sendOtp(phoneNo: RequestBody, result: (Response<OtpResponse>) -> Unit) {
        try {
            softKashApiService.sendOtp(phoneNo)
                .enqueue(object : Callback<OtpResponse>{
                    override fun onResponse(
                        call: Call<OtpResponse>,
                        response: Response<OtpResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<OtpResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun forgotPassword(adminId: Int, token: RequestBody, newPass: RequestBody,
                                        confirmPass: RequestBody, result: (Response<ForgotPasswordResponse>) -> Unit) {
        try {
            softKashApiService.forgotPassword(adminId, token, newPass, confirmPass)
                    .enqueue(object : Callback<ForgotPasswordResponse>{
                        override fun onResponse(call: Call<ForgotPasswordResponse>, response: Response<ForgotPasswordResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<ForgotPasswordResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun changePassword(adminId: Int, oldPass: RequestBody, newPass: RequestBody,
                                        confirmPass: RequestBody, result: (Response<ResetPasswordResponse>) -> Unit) {
        try {
            softKashApiService.changePassword(adminId, oldPass, newPass, confirmPass)
                    .enqueue(object : Callback<ResetPasswordResponse>{
                        override fun onResponse(call: Call<ResetPasswordResponse>, response: Response<ResetPasswordResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<ResetPasswordResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun blockUser(userId: Int, result: (Response<BlockUserResponse>) -> Unit) {
        try {
            softKashApiService.blockUser(userId)
                    .enqueue(object : Callback<BlockUserResponse>{
                        override fun onResponse(call: Call<BlockUserResponse>, response: Response<BlockUserResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<BlockUserResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun unBlockUser(userId: Int, result: (Response<BlockUserResponse>) -> Unit) {
        try {
            softKashApiService.unBlockUser(userId)
                .enqueue(object : Callback<BlockUserResponse>{
                    override fun onResponse(
                        call: Call<BlockUserResponse>,
                        response: Response<BlockUserResponse>
                    ) {
                       result(response)
                    }

                    override fun onFailure(call: Call<BlockUserResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })

        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getSystemAnalysis(result: (Response<SystemAnalysisResponse>) -> Unit) {
        try {
            softKashApiService.getSystemAnalysis()
                .enqueue(object : Callback<SystemAnalysisResponse>{
                    override fun onResponse(
                        call: Call<SystemAnalysisResponse>,
                        response: Response<SystemAnalysisResponse>
                    ) {
                       result(response)
                    }

                    override fun onFailure(call: Call<SystemAnalysisResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getUsers(paginate: String, result: (Response<GetUserResponse>) -> Unit) {
        try {
            softKashApiService.getUsersAsync(paginate)
                .enqueue(object : Callback<GetUserResponse>{
                    override fun onResponse(
                        call: Call<GetUserResponse>,
                        response: Response<GetUserResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<GetUserResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun searchUser(
        paginate: String,
        words: String,
        result: (Response<SearchUserResponse>) -> Unit
    ) {
        try {
            softKashApiService.searchUsers(paginate, words)
                .enqueue(object : Callback<SearchUserResponse>{
                    override fun onResponse(
                        call: Call<SearchUserResponse>,
                        response: Response<SearchUserResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<SearchUserResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun searchLoan(
        paginate: String,
        words: String,
        result: (Response<LoansResponse>) -> Unit
    ) {
       try {
           softKashApiService.searchLoans(paginate, words)
               .enqueue(object : Callback<LoansResponse>{
                   override fun onResponse(
                       call: Call<LoansResponse>,
                       response: Response<LoansResponse>
                   ) {
                       result(response)
                   }

                   override fun onFailure(call: Call<LoansResponse>, t: Throwable) {
                       Log.e("Error", "Network error")
                   }
               })
       }catch (e: Throwable){
           Log.e("connectivity ", "{${e.localizedMessage}}", e)
       }
    }

    override suspend fun searchTransaction(
        paginate: String,
        words: String,
        result: (Response<TransactionResponse>) -> Unit
    ) {
        try {
            softKashApiService.searchTransaction(paginate, words)
                .enqueue(object : Callback<TransactionResponse>{
                    override fun onResponse(
                        call: Call<TransactionResponse>,
                        response: Response<TransactionResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<TransactionResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun logInOtp(token: RequestBody, result: (Response<LoginOtpResponse>) -> Unit) {
        try {
            softKashApiService.logInOtp(token)
                    .enqueue(object : Callback<LoginOtpResponse>{
                        override fun onResponse(call: Call<LoginOtpResponse>, response: Response<LoginOtpResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<LoginOtpResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun searchLoansByDate(
        paginate: String,
        from: String,
        to: String,
        result: (Response<LoansResponse>) -> Unit
    ) {
        try {
            softKashApiService.searchLoansByDate(paginate, from, to)
                .enqueue(object : Callback<LoansResponse>{
                    override fun onResponse(
                        call: Call<LoansResponse>,
                        response: Response<LoansResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<LoansResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun searchTransactionByDate(
        paginate: String,
        from: String,
        to: String,
        result: (Response<TransactionResponse>) -> Unit
    ) {
        try {
            softKashApiService.searchTransactionsByDate(paginate, from, to)
                .enqueue(object : Callback<TransactionResponse>{
                    override fun onResponse(
                        call: Call<TransactionResponse>,
                        response: Response<TransactionResponse>
                    ) {
                       result(response)
                    }

                    override fun onFailure(call: Call<TransactionResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getTypeOfBusiness(result: (Response<TypeOfBusinessResponse>) -> Unit) {
        try {
            softKashApiService.getTypeOfBusiness()
                    .enqueue(object : Callback<TypeOfBusinessResponse>{
                        override fun onResponse(call: Call<TypeOfBusinessResponse>, response: Response<TypeOfBusinessResponse>) {
                            result(response)
                        }

                        override fun onFailure(call: Call<TypeOfBusinessResponse>, t: Throwable) {
                            Log.e("Error", "Network error")
                        }
                    })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun addTypeOfBusiness(
        name: RequestBody,
        desc: RequestBody,
        result: (Response<AddTypeOfBusinessResponse>) -> Unit
    ) {
        try {
            softKashApiService.addTypeOfBusiness(name, desc)
                .enqueue(object : Callback<AddTypeOfBusinessResponse>{
                    override fun onResponse(
                        call: Call<AddTypeOfBusinessResponse>,
                        response: Response<AddTypeOfBusinessResponse>
                    ) {
                       result(response)
                    }

                    override fun onFailure(call: Call<AddTypeOfBusinessResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun deleteTypeOfBusiness(
        id: Int,
        result: (Response<DeleteTypeOfBusinessResponse>) -> Unit
    ) {
        try {
            softKashApiService.deleteTypeOfBusiness(id)
                .enqueue(object : Callback<DeleteTypeOfBusinessResponse>{
                    override fun onResponse(
                        call: Call<DeleteTypeOfBusinessResponse>,
                        response: Response<DeleteTypeOfBusinessResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<DeleteTypeOfBusinessResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getReasonForLoan(result: (Response<ReasonForLoanResponse>) -> Unit) {
        try {
            softKashApiService.getReasonForLoan()
                .enqueue(object : Callback<ReasonForLoanResponse>{
                    override fun onResponse(
                        call: Call<ReasonForLoanResponse>,
                        response: Response<ReasonForLoanResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<ReasonForLoanResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun deleteReasonForLoan(
        id: Int,
        result: (Response<DeleteTypeOfBusinessResponse>) -> Unit
    ) {
        try {
            softKashApiService.deleteReasonForLoan(id)
                .enqueue(object : Callback<DeleteTypeOfBusinessResponse>{
                    override fun onResponse(
                        call: Call<DeleteTypeOfBusinessResponse>,
                        response: Response<DeleteTypeOfBusinessResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<DeleteTypeOfBusinessResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun addReasons(
        name: RequestBody,
        desc: RequestBody,
        result: (Response<AddReasonsRespose>) -> Unit
    ) {
        try {
            softKashApiService.addReasons(name,desc)
                .enqueue(object : Callback<AddReasonsRespose>{
                    override fun onResponse(
                        call: Call<AddReasonsRespose>,
                        response: Response<AddReasonsRespose>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<AddReasonsRespose>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun addLoanProduct(
        productName: RequestBody,
        minAmount: RequestBody,
        maxAmount: RequestBody,
        penalty: RequestBody,
        tenureType: RequestBody,
        minCreditSCore: RequestBody,
        minKycLevel: RequestBody,
        processFees: RequestBody,
        systemCanApprove: RequestBody,
        maxTenure: RequestBody,
        interestRate: RequestBody,
        interestRateType: RequestBody,
        loanType: RequestBody,
        result: (Response<AddLoanProductResponse>) -> Unit
    ) {
        try {
            softKashApiService.addLoanProduct(productName, minAmount,  maxAmount, penalty, tenureType,
            minCreditSCore, minKycLevel, processFees, systemCanApprove, maxTenure, interestRate,
            interestRateType, loanType)
                .enqueue(object : Callback<AddLoanProductResponse>{
                    override fun onResponse(
                        call: Call<AddLoanProductResponse>,
                        response: Response<AddLoanProductResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<AddLoanProductResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun deleteLoanProduct(
        id: Int,
        result: (Response<DeleteLoanProductResponse>) -> Unit
    ) {
        try {
            softKashApiService.deleteLoanProduct(id)
                .enqueue(object : Callback<DeleteLoanProductResponse>{
                    override fun onResponse(
                        call: Call<DeleteLoanProductResponse>,
                        response: Response<DeleteLoanProductResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<DeleteLoanProductResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getBureau(userId: Int, result: (Response<BureauResponse>) -> Unit) {
        try {
            softKashApiService.getBureau(userId)
                .enqueue(object : Callback<BureauResponse>{
                    override fun onResponse(
                        call: Call<BureauResponse>,
                        response: Response<BureauResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<BureauResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getRoles(result: (Response<GetRolesResponse>) -> Unit) {
        try {
            softKashApiService.getRoles()
                .enqueue(object : Callback<GetRolesResponse>{
                    override fun onResponse(
                        call: Call<GetRolesResponse>,
                        response: Response<GetRolesResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<GetRolesResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun addRoles(
        name: RequestBody,
        desc: RequestBody,
        result: (Response<AddRolesResponse>) -> Unit
    ) {
        try {
            softKashApiService.addRoles(name, desc)
                .enqueue(object : Callback<AddRolesResponse>{
                    override fun onResponse(
                        call: Call<AddRolesResponse>,
                        response: Response<AddRolesResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<AddRolesResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun deleteRoles(id: Int, result: (Response<DeleteRolesResponse>) -> Unit) {
        try {
            softKashApiService.deleteRoles(id)
                .enqueue(object : Callback<DeleteRolesResponse>{
                    override fun onResponse(
                        call: Call<DeleteRolesResponse>,
                        response: Response<DeleteRolesResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<DeleteRolesResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun getUnverifiedBVN(result: (Response<UnverifiedResponse>) -> Unit) {
        try {
            softKashApiService.getUnverifiedBVN()
                .enqueue(object : Callback<UnverifiedResponse>{
                    override fun onResponse(
                        call: Call<UnverifiedResponse>,
                        response: Response<UnverifiedResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<UnverifiedResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }

    override suspend fun verifyBVN(
        userId: RequestBody,
        adminId: RequestBody,
        result: (Response<VerifyResponse>) -> Unit
    ) {
        try {
            softKashApiService.verifyBVN(userId, adminId)
                .enqueue(object : Callback<VerifyResponse>{
                    override fun onResponse(
                        call: Call<VerifyResponse>,
                        response: Response<VerifyResponse>
                    ) {
                        result(response)
                    }

                    override fun onFailure(call: Call<VerifyResponse>, t: Throwable) {
                        Log.e("Error", "Network error")
                    }
                })
        }catch (e: Throwable){
            Log.e("connectivity ", "{${e.localizedMessage}}", e)
        }
    }
}