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.
957 lines
39 KiB
957 lines
39 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 requestOTP(mobileNumber: String)
|
|
case submitOTP(otp: String)
|
|
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: - Existing User Registration
|
|
case oldUserAccessRequest(idNumber: String, mobileNumber: String, dob: String)
|
|
case oldUserRegister(registerModel: OldUserRegisterRequestModel, firebaseToken: String)
|
|
case loadExistingUserInformation
|
|
case submitExistingCustomerKYC(model: KYCSaveInformation)
|
|
|
|
// MARK: - New User Registration
|
|
case verifyIdNumber(id: String, type: String)
|
|
case newUserRegister(model: NewUserRegisterModel, fcmToken: String)
|
|
case submitKYC(model: KYCSaveInformation)
|
|
|
|
// 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)
|
|
|
|
// MARK: - Inbound
|
|
case fetchInboundTransactionHistory(from: String, to: String)
|
|
|
|
// MARK: - New Registration
|
|
case loadKYCInformation
|
|
case saveKYCInformation(model: KYCSave)
|
|
case requestPennyTestAtRegister(resend: String)
|
|
case pennyTestSubmitAtRegister(accountNumber: String, certNumber: String)
|
|
case fetchKFTCParameterForRegister
|
|
case customerInfoAgree(_ flag: Bool)
|
|
case checkInfoAgree
|
|
|
|
// MARK: - New Registration
|
|
case getNotifyInfo
|
|
case getNotifyDetailInfo(idx: String)
|
|
|
|
// MARK: - Edit Profile
|
|
case profileCheckPassword(model: ChangePersonalInformationModel, target: String)
|
|
case profileValidationOTP(OTPPassword: String)
|
|
case profileChangeInformation(newValue: String, target: String)
|
|
case resendOTPForChangeProfileInformation(newValue: String)
|
|
case fetchPersonalInformation
|
|
|
|
// MARK: - Transaction
|
|
case searchTxnByControlNumber(controlNumber: String)
|
|
case redeemCashPayment(controlNumber: String, txnId: String, password: String)
|
|
|
|
//Mark: - Withdraw From Wallet
|
|
case withdrawWalletRequest(amount: String)
|
|
case withdrawFromWallet(txnId: String,amount: String, password: String)
|
|
}
|
|
|
|
// 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>(
|
|
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"
|
|
)
|
|
})
|
|
|
|
}
|
|
self.parameters?.forEach { (params) in
|
|
multipartFormData
|
|
.append("\(params.value)".data(using: String.Encoding.utf8)!, withName: params.key as String)
|
|
}
|
|
},
|
|
usingThreshold: UInt64(),
|
|
to: self.endpoint,
|
|
method: self.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 .requestOTP:
|
|
return "\(baseUrl)/mobile/requestOTP"
|
|
case .submitOTP:
|
|
return "\(baseUrl)/mobile/submitOTP"
|
|
case .customerRegister:
|
|
return "\(baseUrlWithoutVersion)v3/mobile/customerRegister"
|
|
case .passwordReset:
|
|
return "\(baseUrl)/mobile/passwordReset"
|
|
case .validation:
|
|
return "\(baseUrlWithoutVersion)v3/validation"
|
|
case .oldUserAccessRequest:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/oldUserAccessRequest"
|
|
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 .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 .fetchInboundTransactionHistory:
|
|
let senderId = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return "\(baseUrl)/inbound/mobile/tranHistory/\(senderId)"
|
|
case .loadKYCInformation:
|
|
let userID = GMEDB.shared.user.string(.userId) ?? ""
|
|
return "\(baseUrlWithoutVersion)v4/mobile/loadform/\(userID)/kyc"
|
|
case .loadExistingUserInformation:
|
|
let userID = GMEDB.shared.user.string(.userId) ?? ""
|
|
return "\(baseUrlWithoutVersion)v4/mobile/loadform/\(userID)/kycExistingCustomer"
|
|
case .saveKYCInformation:
|
|
return "\(baseUrlWithoutVersion)/v4/mobile/RegisterKyc"
|
|
case .submitKYC:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/RegisterKyc"
|
|
case .submitExistingCustomerKYC:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/RegisterKycExistingCustomer"
|
|
case .requestPennyTestAtRegister(let resend):
|
|
let userID = GMEDB.shared.user.string(.userId) ?? ""
|
|
return "\(baseUrl)/mobile/pennytest/start/\(userID)?reSendCode=\(resend)"
|
|
case .fetchKFTCParameterForRegister:
|
|
let userID = GMEDB.shared.user.string(.userId) ?? ""
|
|
return "\(baseUrlWithoutVersion)/v4/GetKftcParameters/\(userID)"
|
|
case .pennyTestSubmitAtRegister:
|
|
return "\(baseUrl)/mobile/pennytest/getcertified"
|
|
case .customerInfoAgree(let flag):
|
|
let userID = GMEDB.shared.user.string(.userId) ?? ""
|
|
return "\(baseUrlWithoutVersion)v3/mobile/customerInfoAgree/\(userID)?agreeYn=\(flag ? "Y" : "N")"
|
|
case .checkInfoAgree:
|
|
let userID = GMEDB.shared.user.string(.userId) ?? ""
|
|
return "\(baseUrl)/mobile/CheckInfoAgree/\(userID)"
|
|
case .getNotifyInfo:
|
|
return "\(baseUrl)/mobile/GetNotifyInfo"
|
|
case .getNotifyDetailInfo:
|
|
return "\(baseUrl)/mobile/GetNotifyDetailInfo"
|
|
case .profileCheckPassword:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/CheckPassword"
|
|
case .profileValidationOTP:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/ValidationOTP"
|
|
case .profileChangeInformation:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/ChangeInformation"
|
|
case .resendOTPForChangeProfileInformation:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/ReSendOTP"
|
|
case .fetchPersonalInformation:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/ProfilepersonalInformation"
|
|
case .searchTxnByControlNumber:
|
|
return "\(baseUrl)/mobile/searchTxnByControlNumber"
|
|
case .redeemCashPayment:
|
|
return "\(baseUrl)/mobile/redeemCashPayment"
|
|
case .withdrawWalletRequest:
|
|
return "\(baseUrl)/mobile/withdrawWalletRequest"
|
|
case .withdrawFromWallet:
|
|
return "\(baseUrl)/mobile/withdrawFromWallet"
|
|
case .oldUserRegister:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/oldUserRegister"
|
|
case .verifyIdNumber:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/verifyIdNumber"
|
|
case .newUserRegister:
|
|
return "\(baseUrlWithoutVersion)v1/mobile/newUserRegister"
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Method
|
|
extension APIRouter {
|
|
private var method: HTTPMethod {
|
|
switch self {
|
|
case .accesscode:
|
|
return .post
|
|
case .customerProfile:
|
|
return .post
|
|
case .requestOTP:
|
|
return .post
|
|
case .submitOTP:
|
|
return .post
|
|
case .customerRegister:
|
|
return .post
|
|
case .passwordReset:
|
|
return .post
|
|
case .validation:
|
|
return .post
|
|
case .oldUserAccessRequest:
|
|
return .post
|
|
case .countriesServices:
|
|
return .get
|
|
case .calculateDefExRate:
|
|
return .post
|
|
case .dynamicReceiver:
|
|
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 .fetchInboundTransactionHistory:
|
|
return .post
|
|
case .loadKYCInformation:
|
|
return .get
|
|
case .loadExistingUserInformation:
|
|
return .get
|
|
case .saveKYCInformation:
|
|
return .post
|
|
case .submitKYC:
|
|
return .post
|
|
case .submitExistingCustomerKYC:
|
|
return .post
|
|
case .requestPennyTestAtRegister:
|
|
return .post
|
|
case .fetchKFTCParameterForRegister:
|
|
return .get
|
|
case .pennyTestSubmitAtRegister:
|
|
return .post
|
|
case .customerInfoAgree:
|
|
return .get
|
|
case .checkInfoAgree:
|
|
return .post
|
|
case .getNotifyInfo:
|
|
return .post
|
|
case .getNotifyDetailInfo:
|
|
return .post
|
|
case .profileCheckPassword:
|
|
return .post
|
|
case .profileValidationOTP:
|
|
return .post
|
|
case .profileChangeInformation:
|
|
return .post
|
|
case .resendOTPForChangeProfileInformation:
|
|
return .post
|
|
case .fetchPersonalInformation:
|
|
return .post
|
|
case .searchTxnByControlNumber:
|
|
return .post
|
|
case .redeemCashPayment:
|
|
return .post
|
|
case .withdrawWalletRequest, .withdrawFromWallet:
|
|
return .post
|
|
case .oldUserRegister:
|
|
return .post
|
|
case .verifyIdNumber:
|
|
return .post
|
|
case .newUserRegister:
|
|
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 .requestOTP(let mobileNumber):
|
|
return ["mobileNumber" : mobileNumber]
|
|
|
|
case .submitOTP(let otp):
|
|
return [
|
|
"mobileNumber" : GMEDB.shared.register.string(.mobileNumber) ?? "",
|
|
"OTP" : otp
|
|
]
|
|
|
|
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(),
|
|
"referenceId": GMEDB.shared.register.string(.referenceId) ?? ""
|
|
]
|
|
|
|
case .oldUserRegister(let registerModel, let firebaseToken):
|
|
return [
|
|
"UserId": GMEDB.shared.user.string(.userId) ?? "",
|
|
"referenceId": GMEDB.shared.register.string(.referenceId) ?? "",
|
|
"Password": registerModel.password ?? "",
|
|
"ConfirmPassword": registerModel.confirmPassword ?? "",
|
|
"TxnPin": registerModel.txnPin ?? "",
|
|
"ConfirmTxnPin": registerModel.confirmTxnPin ?? "",
|
|
"clientId": GMEDB.shared.generatedUserId.string(.generatedUserId) ?? "",
|
|
"uuid": self.uuid,
|
|
"appVersion": Utility.getAppVersion() ?? "",
|
|
"phoneBrand": UIDevice.modelName,
|
|
"phoneOS": Utility.getPhoneOs(),
|
|
"fcmId": firebaseToken,
|
|
"osVersion": Utility.getOsVersion(),
|
|
"referralCode": registerModel.referralCode ?? ""
|
|
]
|
|
|
|
case .newUserRegister(let model, let fcmToken):
|
|
return [
|
|
"ResidenceCardNumber": GMEDB.shared.user.string(.userId) ?? "",
|
|
"UserId": model.userId ?? "",
|
|
"Password": model.password ?? "",
|
|
"ConfirmPassword": model.confirmPassword ?? "",
|
|
"clientId": Utility.getCliendId(),
|
|
"uuid": self.uuid,
|
|
"appVersion": Utility.getAppVersion() ?? "",
|
|
"phoneBrand": UIDevice.modelName,
|
|
"phoneOS": Utility.getPhoneOs(),
|
|
"fcmId": fcmToken,
|
|
"osVersion": Utility.getOsVersion(),
|
|
"referralCode": model.referralCode ?? ""
|
|
]
|
|
|
|
case .passwordReset(let userName):
|
|
return ["username": userName]
|
|
|
|
case .validation(let userName, let idNumber, let idType):
|
|
return [
|
|
"Username": userName,
|
|
"IdNumber": idNumber,
|
|
"IdType": idType
|
|
]
|
|
|
|
case .oldUserAccessRequest(let idNumber, let mobileNumber, let dob):
|
|
return [
|
|
"IdNumber": idNumber,
|
|
"MobileNumber": mobileNumber,
|
|
"Dob": dob
|
|
]
|
|
|
|
case .verifyIdNumber(let id, let type):
|
|
return [
|
|
"type": type,
|
|
"idnumber": id
|
|
]
|
|
|
|
case .calculateDefExRate(let model):
|
|
return model.serialize()
|
|
|
|
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.branch?.code ?? validateModel.bank?.code ?? "",
|
|
"Amount": validateModel.amount,
|
|
"PayoutPartner": validateModel.payoutPartner,
|
|
"ProcessId": "",
|
|
"BankId": validateModel.bank?.id ?? "",
|
|
"ReceiverCountryId": validateModel.country?.countryId ?? "",
|
|
"deliveryMethodId": validateModel.paymentMethod?.id ?? ""
|
|
]
|
|
|
|
case .fetchInboundTransactionHistory(let from, let to):
|
|
return [
|
|
"FromDate": from,
|
|
"ToDate": to,
|
|
"tranId": ""
|
|
]
|
|
|
|
case .saveKYCInformation(let model):
|
|
let userID = GMEDB.shared.user.string(.userId) ?? ""
|
|
return [
|
|
"userId" : userID,
|
|
"type": model.type,
|
|
"fullName": model.personalInformation?.fullName ?? "",
|
|
"gender": model.personalInformation?.gender ?? "",
|
|
"dob": model.personalInformation?.dob ?? "",
|
|
"email": model.personalInformation?.email ?? "",
|
|
"city": model.personalInformation?.city ?? "",
|
|
"address": model.personalInformation?.address ?? "",
|
|
"occupation": model.personalInformation?.occupation ?? "",
|
|
"nativeCountry": model.personalInformation?.nativeCountry ?? "",
|
|
"bankId": model.primaryInformation?.bankID ?? "",
|
|
"bankAccount": model.primaryInformation?.bankAccount ?? "",
|
|
"passportNumber": model.primaryInformation?.passportNumber ?? "",
|
|
"passportIssueDate": model.primaryInformation?.passportIssueDate ?? "",
|
|
"passportExpiryDate": model.primaryInformation?.passportExpiryDate ?? "",
|
|
"anotherIDType": model.primaryInformation?.anotherIDType ?? "",
|
|
"anotherIDNumber": model.primaryInformation?.anotherIDNumber ?? "",
|
|
"anotherIDIssueDate": model.primaryInformation?.anotherIDIssueDate ?? "",
|
|
"anotherIDExpiryDate": model.primaryInformation?.anotherIDExpiryDate ?? "",
|
|
"branchId": model.primaryInformation?.branchID ?? "",
|
|
"refferalCode": model.primaryInformation?.refferalCode ?? ""
|
|
]
|
|
|
|
case .submitKYC(let model):
|
|
return [
|
|
"type": model.type,
|
|
"employeerName": model.personalInformation?.employeerName ?? "",
|
|
"sourceOfFund": model.personalInformation?.sourceOfFund ?? "",
|
|
"monthlyIncome": model.personalInformation?.monthlyIncome ?? "",
|
|
"businessType": model.personalInformation?.businessType ?? "",
|
|
"mobile": model.personalInformation?.mobile ?? "",
|
|
"email": model.personalInformation?.email ?? "",
|
|
"additionalAddress": model.personalInformation?.address ?? "",
|
|
"idType": model.personalInformation?.idType ?? "",
|
|
"additionalIdType": model.personalInformation?.additionalIdType ?? "",
|
|
"userId": GMEDB.shared.user.string(.userId) ?? "",
|
|
"occupation": model.personalInformation?.occupation ?? ""
|
|
]
|
|
|
|
case .submitExistingCustomerKYC(let model):
|
|
return [
|
|
"type": model.type,
|
|
"employeerName": model.personalInformation?.employeerName ?? "",
|
|
"sourceOfFund": model.personalInformation?.sourceOfFund ?? "",
|
|
"monthlyIncome": model.personalInformation?.monthlyIncome ?? "",
|
|
"businessType": model.personalInformation?.businessType ?? "",
|
|
"mobile": model.personalInformation?.mobile ?? "",
|
|
"email": model.personalInformation?.email ?? "",
|
|
"additionalAddress": model.personalInformation?.address ?? "",
|
|
"idType": model.personalInformation?.idType ?? "",
|
|
"visaStatus": model.personalInformation?.additionalIdType ?? "",
|
|
"userId": GMEDB.shared.user.string(.userId) ?? "",
|
|
"occupation": model.personalInformation?.occupation ?? ""
|
|
]
|
|
|
|
case .pennyTestSubmitAtRegister(let accountNumber, let certNumber):
|
|
let senderID = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return [
|
|
"AccountNo": accountNumber,
|
|
"CertNumber": certNumber,
|
|
"CustomerId": senderID
|
|
]
|
|
|
|
case .getNotifyInfo:
|
|
let senderId = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return [
|
|
"customerId": senderId
|
|
]
|
|
|
|
case .getNotifyDetailInfo(let idx):
|
|
return [
|
|
"rowId": idx
|
|
]
|
|
|
|
case .profileCheckPassword(let model, let target):
|
|
let senderId = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return [
|
|
"userId": senderId,
|
|
"password": model.passwordForChangePersonalInformation ?? "",
|
|
"tempValue": model.newValue ?? "",
|
|
"targetInfo": target
|
|
]
|
|
|
|
case .profileValidationOTP(let OTPPassword):
|
|
let senderId = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return [
|
|
"userId": senderId,
|
|
"OTPNumber": OTPPassword
|
|
]
|
|
|
|
case .profileChangeInformation(let newValue, let target):
|
|
let senderId = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return [
|
|
"userId": senderId,
|
|
"newValue": newValue,
|
|
"targetInfo": target
|
|
]
|
|
|
|
case .resendOTPForChangeProfileInformation(let newValue):
|
|
let senderId = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return [
|
|
"userId" : senderId,
|
|
"tempValue" : newValue
|
|
]
|
|
|
|
case .fetchPersonalInformation:
|
|
let userId = GMEDB.shared.user.string(.senderId) ?? ""
|
|
return [
|
|
"userId" : userId
|
|
]
|
|
|
|
case .searchTxnByControlNumber(let controlNumber):
|
|
return [
|
|
"userId" : GMEDB.shared.user.string(.userId) ?? "",
|
|
"controlNumber": controlNumber
|
|
]
|
|
|
|
case .redeemCashPayment(let controlNumber, let txnId, let password):
|
|
return [
|
|
"userId" : GMEDB.shared.user.string(.userId) ?? "",
|
|
"controlNumber": controlNumber,
|
|
"txnId": txnId,
|
|
"password": password
|
|
]
|
|
|
|
case .withdrawWalletRequest(let amount):
|
|
return [
|
|
"userId" : GMEDB.shared.user.string(.userId) ?? "",
|
|
"amount": amount
|
|
]
|
|
|
|
case .withdrawFromWallet(let txnId, let amount, let password):
|
|
return [
|
|
"userId" : GMEDB.shared.user.string(.userId) ?? "",
|
|
"amount": amount,
|
|
"txnId" : txnId,
|
|
"password" : password
|
|
]
|
|
|
|
default: return nil
|
|
}
|
|
|
|
default : return nil
|
|
}
|
|
}
|
|
}
|