LONDON-IOS/GME Remit/APIs/Router/APIRouter.swift

//
//  APIRouter.swift
//  GME Remit
//
//  Created by InKwon James Kim on 09/08/2019.
//  Copyright © 2019 Gobal Money Express Co. Ltd. All rights reserved.
//

import Foundation
import Alamofire
import Localize_Swift
import ObjectMapper

import RxSwift

class APIManager {
  static let shared = APIManager()
  let manager: SessionManager
  
  init() {
    let configure = URLSessionConfiguration.default
    configure.timeoutIntervalForRequest = 300.0
    configure.timeoutIntervalForResource = 300.0
    
    manager = Alamofire.SessionManager(configuration: configure)
  }
}

enum APIRouter {
  // MARK: - Login
  case accesscode(username: String, password: String)
  case customerProfile(firebaseToken: String)
  
  // MARK: - Register
  case customerRegister(registerModel: RegisterRequestModel, firebaseToken: String)
  case passwordReset(userName: String)
  case validation(userName: String, idNumber: String, idType: String)
  case countriesServices
  case calculateDefExRate(model: ExchangeRateRequestModel)
  
  // MARK: - KFTC
  case getKFTCParamers(username: String)
  case deleteAutoDebitAccount(username: String, kftcLogID: String)
  case renewalToken(username: String)
  case fetchBankList
  case checkRealName(model: VerifyAccountRequestModel)
  case fetchKFTCURL(url: String)
  case domesticRemitStart
  case getRecentHistories(from: String, to: String)
  case fetchBalace(type: String, fintechUseNumber: String)
  case fetchRecipientName(bankCode: String, accountNumber: String)
  case sendDomesticRemit(model: DomesticRemitRequestModel)
  
  // MARK: - Receiver
  case fetchRecipients(senderID: String)
  case dynamicReceiver(username: String, countryID: String, serviceTypeID: String)
  case fetchCountriesAndServiceTypes(username: String)
  case addRecipient(senderID: String, recipient: Recipient)
  case editRecipient(senderID: String, recipient: Recipient)
  case deleteRecipient(senderID: String, recipientID: String)
  case fetchBranches(countryCode: String, bankID: String, branchName: String)
  case validateAccount(validateModel: ValidateAccountRequest)
  
  case domesticTransactionHistory(from: String, to: String)
  case domesticReceipt(transactionID: String)
  
  // MARK: - Recharge Prepiad Phone
  case fetchCardList(type: String, mobile: String)
  case verificationAndBuy(model: RechargeModel)
  case fetchRechargeHistory(from: String, to: String)
  
  // MARK: - Inbound
  case penneyTestStart(model: PenneyTestRequest, isResend: String)
  case penneyTestCertified(model: PenneyTestVerify)
  case fetchInboundAccounts
  case fetchInboundTransactionHistory(from: String, to: String)
  case deleteInboundAccount(model: InboundAccount)
  
  // MARK: - New Registration
  case loadKYCInformation
  case saveKYCInformation(model: KYCSave)
}

// MARK: - Request
extension APIRouter: ApiServiceType {
  private var manager: SessionManager {
    return APIManager.shared.manager
  }
  
  private var uuid: String {
    guard let uuid = GMEDB.shared.app.string(.uuid) else {
      let uuid = UUID().uuidString
      GMEDB.shared.app.set(uuid, .uuid)
      return uuid
    }
    
    return uuid
  }
  
  private var beforeLoginHeader: [String: String] {
    let currentLanguage = Localize.currentLanguage()
    let lang = Utility.getLanguageHeader(for: currentLanguage)
    let authValue = "172017F9EC11222E8107142733:QRK2UM0Q:\(uuid)".toBase64()
    
    return [
      "Authorization": "Basic \(authValue)",
      "GME-TOKEN" : "39587YT398@FBQOW8RY3#948R7GB@CNEQW987GF87$TD18$1981..919@@##joghndvberteiru",
      "Content-Type": "application/json",
      "lang" : lang
    ]
  }
  
  private var afterLoginHeader: [String: String] {
    let accessCode = GMEDB.shared.user.string(.accessCode) ?? ""
    let currentLanguage = Localize.currentLanguage()
    let lang = Utility.getLanguageHeader(for: currentLanguage)
    
    return [
      "Authorization": "Bearer " + accessCode,
      "GME-TOKEN" : "39587YT398@FBQOW8RY3#948R7GB@CNEQW987GF87$TD18$1981..919@@##joghndvberteiru",
      "Content-Type": "application/json",
      "clientId": Utility.getMyKftcClientId(),
      "lang" : lang
    ]
  }
  
  func json(
    encoding: ParameterEncoding = JSONEncoding.default,
    needsAuthorization: Bool = true,
    success: @escaping () -> Void,
    failure: @escaping (Error) -> Void
  ) {
    guard
      let isReachable = NetworkReachabilityManager()?.isReachable,
      isReachable else {
        let error = NSError(
          domain: "NETWORK_REACHABILITY_DOMAIN",
          code: -99,
          message: "No Internet connection found. Check your connection."
        )
        return failure(error)
    }
    
    manager.request(
      self.endpoint,
      method: self.method,
      parameters: self.parameters,
      encoding: encoding,
      headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
    ).handle(
      success: { (response: ResponseContainer<Void>) in
        if (response.errorCode ?? "") != "0" {
          let code = Int(response.errorCode ?? "1") ?? 1
          let error = NSError(domain: "Network", code: code, message: response.message ?? "")
          failure(error)
        } else {
          success()
        }
    },
      failure: failure
    )
  }
  
  func json<Element>(
    encoding: ParameterEncoding = JSONEncoding.default,
    needsAuthorization: Bool = true,
    success: @escaping (Element) -> Void,
    failure: @escaping (Error) -> Void
  ) {
    guard
      let isReachable = NetworkReachabilityManager()?.isReachable,
      isReachable else {
        let error = NSError(
          domain: "NETWORK_REACHABILITY_DOMAIN",
          code: -99,
          message: "No Internet connection found. Check your connection."
        )
        return failure(error)
    }
    
    manager.request(
      self.endpoint,
      method: self.method,
      parameters: self.parameters,
      encoding: encoding,
      headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
    ).handle(
      success: { (response: ResponseContainer<Element>) in
        if (response.errorCode ?? "") != "0" {
          let code = Int(response.errorCode ?? "1") ?? 1
          let error = NSError(domain: "Network", code: code, message: response.message ?? "")
          failure(error)
        } else {
          guard let data = response.data else {
            let error = NSError(domain: "Network", code: 0, message: "Data is nil")
            failure(error)
            return
          }
          success(data)
        }
    },
      failure: failure
    )
  }
  
  func json<Element: Mappable>(
    encoding: ParameterEncoding = JSONEncoding.default,
    needsAuthorization: Bool = true,
    success: @escaping (Element) -> Void,
    failure: @escaping (Error) -> Void
  ) {
    guard
      let isReachable = NetworkReachabilityManager()?.isReachable,
      isReachable else {
        let error = NSError(
          domain: "NETWORK_REACHABILITY_DOMAIN",
          code: -99,
          message: "No Internet connection found. Check your connection."
        )
        return failure(error)
    }
    
    manager.request(
      self.endpoint,
      method: self.method,
      parameters: self.parameters,
      encoding: encoding,
      headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
    )
      .handle(
        success: { (response: ResponseContainerObject<Element>) in
          if (response.errorCode ?? "") != "0" {
            let code = Int(response.errorCode ?? "1") ?? 1
            let error = NSError(domain: "Network", code: code, message: response.message ?? "")
            failure(error)
          } else {
            guard let data = response.data else {
              let error = NSError(domain: "Network", code: 0, message: "Data is nil")
              failure(error)
              return
            }
            success(data)
          }
      },
        failure: failure
    )
  }
  
  func json<Element: Mappable>(
    encoding: ParameterEncoding = JSONEncoding.default,
    needsAuthorization: Bool = true,
    success: @escaping ([Element]) -> Void,
    failure: @escaping (Error) -> Void
  ) {
    guard
      let isReachable = NetworkReachabilityManager()?.isReachable,
      isReachable else {
        let error = NSError(
          domain: "NETWORK_REACHABILITY_DOMAIN",
          code: -99,
          message: "No Internet connection found. Check your connection."
        )
        return failure(error)
    }
    
    manager.request(
      self.endpoint,
      method: self.method,
      parameters: self.parameters,
      encoding: encoding,
      headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
    )
      .handle(
        success: { (response: ResponseContainerArray<Element>) in
          if (response.errorCode ?? "") != "0" {
            let code = Int(response.errorCode ?? "1") ?? 1
            let error = NSError(domain: "Network", code: code, message: response.message ?? "")
            failure(error)
          } else {
            guard let data = response.data else {
              let error = NSError(domain: "Network", code: 0, message: "Data is nil")
              failure(error)
              return
            }
            success(data)
          }
      },
        failure: failure
    )
  }
  
  func request<T: Mappable>(
    encoding: ParameterEncoding = JSONEncoding.default,
    needsAuthorization: Bool = true,
    success: @escaping (T) -> Void,
    failure: @escaping (Error) -> Void
  ) {
    guard
      let isReachable = NetworkReachabilityManager()?.isReachable,
      isReachable else {
        let error = NSError(
          domain: "NETWORK_REACHABILITY_DOMAIN",
          code: -99,
          message: "No Internet connection found. Check your connection."
        )
        return failure(error)
    }
    
    manager.request(
      self.endpoint,
      method: self.method,
      parameters: self.parameters,
      encoding: encoding,
      headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader
    ).handle(success: success, failure: failure)
  }
  
  func kftcRequest<T: Mappable>(
    header: [String: String],
    encoding: ParameterEncoding = JSONEncoding.default,
    success: @escaping (T) -> Void,
    failure: @escaping (Error) -> Void
  ) {
    guard
      let isReachable = NetworkReachabilityManager()?.isReachable,
      isReachable else {
        let error = NSError(
          domain: "NETWORK_REACHABILITY_DOMAIN",
          code: -99,
          message: "No Internet connection found. Check your connection."
        )
        return failure(error)
    }
    
    manager.request(
      self.endpoint,
      method: self.method,
      parameters: self.parameters,
      encoding: encoding,
      headers: header
    ).handle(success: success, failure: failure)
    
  }
  
  func requestMultipart<T: Mappable>(
    method: HTTPMethod,
    _ URLString: URLConvertible,
    parameters: [String: String]? = nil,
    images: [String: Data],
    encoding: Alamofire.ParameterEncoding = URLEncoding.default,
    needsAuthorization: Bool = true,
    success: @escaping (T) -> Void,
    failure: @escaping (Error) -> Void
  ) {
    guard
      let isReachable = NetworkReachabilityManager()?.isReachable,
      isReachable else {
        let error = NSError(
          domain: "NETWORK_REACHABILITY_DOMAIN",
          code: -99,
          message: "No Internet connection found. Check your connection."
        )
        return failure(error)
    }
    
    manager.upload(
      multipartFormData: { multipartFormData in
        if !images.isEmpty {
          images.forEach({ (data) in
            multipartFormData.append(
              data.value,
              withName: data.key,
              fileName: data.key + ".jpeg",
              mimeType: "image/jpeg"
            )
          })
          
        }
        parameters?.forEach { (params) in
          multipartFormData.append(
            params.value.data(
              using: String.Encoding.utf8,
              allowLossyConversion: false
              )!,
            withName: params.key
          )
        }
    },
      to: URLString,
      method: method,
      headers: needsAuthorization ? afterLoginHeader : beforeLoginHeader,
      encodingCompletion: { encodingResult in
        switch encodingResult {
        case .success(let upload, _, _):
          upload.handle(success: success, failure: failure)
        case .failure:
          let error = NSError(
            domain: "NETWORK_REACHABILITY_DOMAIN",
            code: -99,
            message: "No Internet connection found. Check your connection."
          )
          failure(error)
        }
    }
    )
  }
}

// MARK: - Endpoint
extension APIRouter {
  private var endpoint: String {
    switch self {
    case .accesscode:
      return "\(baseUrl)/users/access-code"
    case .customerProfile:
      return "\(baseUrl)/mobile/CustomerProfile"
    case .customerRegister:
      return "\(baseUrlWithoutVersion)/v3/mobile/customerRegister"
    case .passwordReset:
      return "\(baseUrl)/mobile/passwordReset"
    case .validation:
      return "\(baseUrlWithoutVersion)/v3/validation"
    case .countriesServices:
      return "\(baseUrl)/mobile/countriesServices"
    case .calculateDefExRate:
      return "\(baseUrl)/mobile/calculateDefExRate"
    case .dynamicReceiver(let username, let countryID, let serviceType):
      let path = "\(username)/dynamicField?countryId=\(countryID)&serviceType=\(serviceType)"
      return "\(baseUrlWithoutVersion)v3/mobile/receiver/\(path)"
    case .getKFTCParamers(let username):
      return "\(baseUrl)/kftc/GetKftcParameters/\(username)"
    case .deleteAutoDebitAccount(let username, _):
      return "\(baseUrl)/kftc/DeleteAccount/\(username)"
    case .renewalToken(let username):
      return "\(baseUrl)/kftc/CheckKFTCAccounts/\(username)"
    case .fetchBankList:
      return "\(baseUrl)/kftc/KFTCBankList"
    case .checkRealName:
      return "\(baseUrl)/kftc/CheckRealName"
    case .fetchKFTCURL(let url):
      return url
    case .fetchRecipients(let senderID):
      return "\(baseUrlWithoutVersion)v3/mobile/\(senderID)/receiverinfo"
    case .fetchCountriesAndServiceTypes(let username):
      return "\(baseUrlWithoutVersion)v3/mobile/\(username)/FetchCountriesAndServiceTypes"
    case .addRecipient(let senderID, _):
      return "\(baseUrlWithoutVersion)v3/mobile/\(senderID)/receiverinfo/add"
    case .editRecipient(let senderID, let recipient):
      let recipientID = recipient.receiverID ?? ""
      return "\(baseUrlWithoutVersion)/v3/mobile/\(senderID)/receiverinfo/modify/\(recipientID)"
    case .deleteRecipient(let senderID, let recipientID):
      return "\(baseUrlWithoutVersion)/v3/mobile/\(senderID)/receiverinfo/remove/\(recipientID)"
    case .fetchBranches(let countryCode, let bankID, let branchName):
      return "\(baseUrl)/mobile/sendmoney/load/branch/\(countryCode)/\(bankID)/?search=\(branchName)"
    case .validateAccount:
      return "\(baseUrl)/mobile/sendmoney/validation/account"
      
    case .domesticRemitStart:
      return "\(baseUrl)/kftc/DomeRemitStart"
    case .getRecentHistories:
      return "\(baseUrl)/kftc/GetRecentHistories"
    case .fetchBalace:
      return "\(baseUrl)/kftc/CheckBalance"
    case .fetchRecipientName:
      return "\(baseUrl)/kftc/GetRecipientInfo"
    case .sendDomesticRemit:
      return "\(baseUrl)/kftc/SendDomeRimit"
    case .domesticTransactionHistory:
      let userID = GMEDB.shared.user.string(.userId) ?? ""
      return "\(baseUrl)/mobile/DomestricTranhistory/\(userID)"
    case .domesticReceipt(let transactionID):
      return "\(baseUrl)/mobile/DomesticReceipt/\(transactionID)"
    case .fetchCardList:
      return "\(baseUrl)/powerCall/GetCardList/"
    case .verificationAndBuy:
      return "\(baseUrl)/powerCall/VerificationAndBuy/"
    case .fetchRechargeHistory:
      return "\(baseUrl)/powerCall/GetChargeHistory/"
    case .penneyTestStart(_, let isResend):
      let senderId = GMEDB.shared.user.string(.senderId) ?? ""
      return "\(baseUrl)/inbound/mobile/pennytest/start/\(senderId)?reSendCode=\(isResend)"
    case .penneyTestCertified:
      return "\(baseUrl)/inbound/mobile/pennytest/getcertified"
    case .fetchInboundAccounts:
      let senderId = GMEDB.shared.user.string(.senderId) ?? ""
      return "\(baseUrl)/inbound/mobile/bankaccounts/\(senderId)"
    case .fetchInboundTransactionHistory:
      let senderId = GMEDB.shared.user.string(.senderId) ?? ""
      return "\(baseUrl)/inbound/mobile/tranHistory/\(senderId)"
    case .deleteInboundAccount(let model):
      let senderId = GMEDB.shared.user.string(.senderId) ?? ""
      return "\(baseUrl)/inbound/mobile/deleteInboundAccount/\(senderId)/\(model.id ?? "")"
    case .loadKYCInformation:
      let userID = GMEDB.shared.user.string(.userId) ?? ""
      return "\(baseUrlWithoutVersion)/v4/Mobile/loadform/\(userID)/kyc"
    case .saveKYCInformation:
      return "\(baseUrlWithoutVersion)/v4/mobile/RegisterKyc"
    }
  }
}

// MARK: - Method
extension APIRouter {
  private var method: HTTPMethod {
    switch self {
    case .accesscode:
      return .post
    case .customerProfile:
      return .post
    case .customerRegister:
      return .post
    case .passwordReset:
      return .post
    case .validation:
      return .post
    case .countriesServices:
      return .get
    case .calculateDefExRate:
      return .post
    case .dynamicReceiver:
      return .post
    case .getKFTCParamers:
      return .get
    case .deleteAutoDebitAccount:
      return .post
    case .renewalToken:
      return .get
    case .fetchBankList:
      return .get
    case .checkRealName:
      return .post
    case .fetchKFTCURL:
      return .get
    case .fetchRecipients:
      return .get
    case .fetchCountriesAndServiceTypes:
      return .get
    case .addRecipient:
      return .post
    case .editRecipient:
      return .post
    case .deleteRecipient:
      return .post
    case .fetchBranches:
      return .post
    case .validateAccount:
      return .post
    case .domesticRemitStart:
      return .post
    case .getRecentHistories:
      return .post
    case .fetchBalace:
      return .post
    case .fetchRecipientName:
      return .post
    case .sendDomesticRemit:
      return .post
    case .domesticTransactionHistory:
      return .post
    case .domesticReceipt:
      return .post
    case .fetchCardList:
      return .post
    case .verificationAndBuy:
      return .post
    case .fetchRechargeHistory:
      return .post
    case .penneyTestStart:
      return .post
    case .penneyTestCertified:
      return .post
    case .fetchInboundAccounts:
      return .post
    case .fetchInboundTransactionHistory:
      return .post
    case .deleteInboundAccount:
      return .post
    case .loadKYCInformation:
      return .get
    case .saveKYCInformation:
      return .post
    }
    
  }
}

// MARK: - Parameter
extension APIRouter {
  private var parameters: Parameters? {
    switch self.method {
    case .post:
      switch self {
      case .accesscode(let username, let password):
        return [
          "userId": username,
          "password": password
        ]
        
      case .customerProfile(let firebaseToken):
        return [
          "userId" : Utility.getMyUserName(),
          "uuid": self.uuid,
          "appVersion": Utility.getAppVersion() ?? "",
          "phoneBrand": UIDevice.modelName,
          "phoneOs": Utility.getPhoneOs(),
          "fcmId": firebaseToken,
          "osVersion": Utility.getOsVersion()
        ]
        
      case .customerRegister(let registerModel, let firebaseToken):
        return [
          "username": registerModel.username ?? "",
          "password": registerModel.encryptedPassword ?? "",
          "nativecountry": registerModel.nativeCountry ?? "",
          "mobilenumber": registerModel.mobileNumber ?? "",
          "clientId": Utility.getCliendId(),
          "uuid": self.uuid,
          "appVersion": Utility.getAppVersion() ?? "",
          "phoneBrand": UIDevice.modelName,
          "phoneOs": Utility.getPhoneOs(),
          "fcmId": firebaseToken,
          "osVersion": Utility.getOsVersion()
        ]
        
      case .passwordReset(let userName):
        return ["username": userName]
        
      case .validation(let userName, let idNumber, let idType):
        return [
          "Username": userName,
          "IdNumber": idNumber,
          "IdType": idType
        ]
      case .calculateDefExRate(let model):
        return model.serialize()
      case .deleteAutoDebitAccount(_, let kftcLogID):
        return [
          "KftcLogId" : kftcLogID
        ]
        
      case .checkRealName(let model):
        return [
          "CustomerId": model.customerID,
          "BankCode": model.bankCode,
          "AccountNumber": model.accountNumber
        ]
        
      case .dynamicReceiver:
        return nil
        
      case .addRecipient(_, let recipient):
        let paymentMethod = [
          "id": recipient.paymentMethod?.id ?? "",
          "name": recipient.paymentMethod?.name ?? "",
          "currency": recipient.paymentMethod?.currency ?? [],
          "localizedName": recipient.paymentMethod?.localizedName ?? ""
          ] as [String : Any]
        
        let branch = [
          "id": recipient.agent?.branch?.id ?? "",
          "name": recipient.agent?.branch?.name ?? "",
          "localizedName": recipient.agent?.branch?.name ?? ""
        ]
        
        let agent = [
          "id": recipient.agent?.id ?? "",
          "name": recipient.agent?.name ?? "",
          "currency": recipient.agent?.currency ?? [],
          "localizedName": recipient.agent?.localizedName ?? "",
          "branch": branch,
          "accountNo": recipient.agent?.accountNumber ?? ""
          ] as [String : Any]
        
        return [
          "firstName": recipient.firstName ?? "",
          "middleName": recipient.middleName ?? "",
          "lastName": recipient.lastName ?? "",
          "localFirstName": recipient.localFirstName ?? "",
          "localMiddleName": recipient.localMiddleName ?? "",
          "localLastName": recipient.localLastName ?? "",
          "localFullName": recipient.localFullName ?? "",
          "paymentMethod": paymentMethod,
          "agent": agent,
          "receiverId": recipient.receiverID ?? "",
          "country": recipient.country ?? "",
          "countryId": recipient.countryID ?? "",
          "countryCode": recipient.countryCode ?? "",
          "address": recipient.address ?? "",
          "state": recipient.state ?? "",
          "stateId": recipient.stateID ?? "",
          "city": recipient.city ?? "",
          "email": recipient.email ?? "",
          "mobile": recipient.mobile ?? "",
          "relationship": recipient.relationship ?? "",
          "relationshipId": recipient.relationshipID ?? "",
          "district": recipient.district ?? "",
          "districtId": recipient.districtID ?? "",
          "purposeOfRemit": recipient.purposeOfRemit ?? "",
          "purposeOfRemitId": recipient.purposeOfRemitID ?? "",
          "fullName": recipient.fullName ?? "",
          "idType": recipient.idType ?? "",
          "idNumber": recipient.idNumber ?? "",
          "nativeCountry": recipient.nativeCountry ?? "",
          "nativeCountryID": recipient.nativeCountryID ?? "",
          "nativeCountryCode": recipient.nativeCountryCode ?? ""
        ]
        
      case .editRecipient(let senderID, let recipient):
        return APIRouter.addRecipient(senderID: senderID, recipient: recipient).parameters
        
      case .validateAccount(let validateModel):
        return [
          "IdType" : "1",
          "IdNumber": "",
          "CustomerFirstName": "",
          "CustomerLastName": "",
          "ReceiverFirstName": validateModel.firstName,
          "ReceiverLastName": validateModel.lastName,
          "Country": validateModel.country?.countryCode ?? "",
          "AccountType": validateModel.accountType,
          "IssuerCode": validateModel.bank?.code ?? "",
          "AccountNo": validateModel.accountNumber,
          "BankCode": validateModel.bank?.code ?? "",
          "Amount": validateModel.amount,
          "PayoutPartner": validateModel.payoutPartner,
          "ProcessId": "",
          "BankId": validateModel.bank?.id ?? "",
          "ReceiverCountryId": validateModel.country?.countryId ?? "",
          "deliveryMethodId": validateModel.paymentMethod?.id ?? ""
        ]
        
      case .domesticRemitStart:
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        return ["CustomerId": senderID]
        
      case .getRecentHistories(let from, let to):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        return [
          "CustomerId": senderID,
          "FromDate": from,
          "ToDate": to
        ]
        
      case .fetchBalace(let type, let fintechUseNumber):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        return [
          "CustomerId": senderID,
          "type": type,
          "FintechUseNo": fintechUseNumber
        ]
        
      case .fetchRecipientName(let bankCode, let accountNumber):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        return [
          "CustomerId": senderID,
          "BankCode": bankCode,
          "AccountNumber": accountNumber
        ]
        
      case .sendDomesticRemit(let model):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        let userID = GMEDB.shared.user.string(.userId) ?? ""
        return [
          "CustomerId": senderID,
          "userId": userID,
          "FintechUseNo": model.fintechID,
          "SentAmount": model.sendAmount,
          "RecipientBankCode": model.bankCode,
          "RecipientAccountNo": model.accountNumber,
          "RecipientName": model.name,
          "RecipientPhone": model.mobile,
          "isUseBiometric": model.isUseBiometric,
          "txnPassword":  model.password,
          "KftcAccountId" : model.accountID,
          "type": model.type
        ]
        
      case .domesticTransactionHistory(let from, let to):
        return [
          "FromDate": from,
          "ToDate": to
        ]
        
      case .fetchCardList(let type, let mobile):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        return [
          "CustomerId" : senderID,
          "getcardType": type,
          "phoneNo": mobile
        ]
      case .verificationAndBuy(let model):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
//        let now = Date()
//        let timestamp = "\(Int64(now.timeIntervalSince1970 * 1000))"
        return [
          "BuyType" : model.type,
          "CustomerId" : senderID,
          "ReceiptId" : model.receiptID ?? "",
//          "OrderNo" : model.orderNo ?? timestamp,
          "ChargeType": model.chargeType,
          "CardName": model.cardName,
          "PhoneNo" : model.mobile,
          "ProductPrice" : model.productPrice ?? "",
          "UseBalancePrice" : model.useBalancePrice ?? "",
          "PassWord": model.password ?? ""
        ]
      case .fetchRechargeHistory(let from, let to):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        return [
          "CustomerId": senderID,
          "FromDate" : from,
          "ToDate": to
        ]
        
      case .penneyTestStart(let model, _):
        return [
          "accountID": model.accountID ?? "",
          "accountType": model.accountType ?? "",
          "BankCode": model.bank.bankCode ?? "",
          "AccountNo": model.account
        ]
        
      case .penneyTestCertified(let model):
        let senderID = GMEDB.shared.user.string(.senderId) ?? ""
        return [
          "CustomerId": senderID,
          "BankCode": model.bankCode,
          "AccountNo": model.accountNo,
          "CertNumber": model.verifyNo,
          "accountID": model.accountID ?? "",
          "accountType": model.accountType ?? ""
        ]
        
      case .fetchInboundTransactionHistory(let from, let to):
        return [
          "FromDate": from,
          "ToDate": to,
          "tranId": ""
        ]
        
      case .saveKYCInformation(let model):
        let userID = GMEDB.shared.user.string(.userId) ?? ""
        
        var personalInformation: [String: Any]?
        if model.personalInformation != nil {
          personalInformation = [
            "fullName": model.personalInformation?.fullName ?? "",
            "gender": model.personalInformation?.gender ?? "",
            "dob": model.personalInformation?.dob ?? "",
            "email": model.personalInformation?.email ?? "",
            "city": model.personalInformation?.city ?? "",
            "address": model.personalInformation?.address ?? ""
          ]
        }
        
        var primaryInformation: [String: Any]?
        if model.primaryInformation != nil {
          primaryInformation = [
            "bankId": model.primaryInformation?.bankID ?? "",
            "bankAccount": model.primaryInformation?.bankAccount ?? "",
            "passportNumber": model.primaryInformation?.passportNumber ?? "",
            "passportIssueDate": model.primaryInformation?.passportIssueDate ?? "",
            "passportExpiryDate": model.primaryInformation?.passportExpiryDate ?? "",
            "anotherIDTypeId": model.primaryInformation?.anotherIDType ?? "",
            "anotherIDNumber": model.primaryInformation?.anotherIDNumber ?? "",
            "anotherIDIssueDate": model.primaryInformation?.anotherIDIssueDate ?? "",
            "anotherIDExpiryDate": model.primaryInformation?.anotherIDExpiryDate ?? "",
            "branchId": model.primaryInformation?.branchID ?? "",
            "refferalCode": model.primaryInformation?.refferalCode ?? ""
          ]
        }
        
        var pictureInformation: [String: Any]?
        if model.pictures != nil {
          pictureInformation = [
            "passportPicture": model.pictures?.passportPicture ?? "",
            "anotherIDPicture": model.pictures?.anotherIDPicture ?? ""
          ]
        }
        
        return [
          "userId" : userID,
          "type": model.type,
          "personalInformation": personalInformation as Any,
          "pictures": pictureInformation as Any,
          "primaryInformation": primaryInformation as Any
        ]
      default: return nil
      }
      
    default : return nil
    }
  }
}