You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
894 lines
30 KiB
894 lines
30 KiB
//
|
|
// 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
|
|
}
|
|
}
|
|
}
|