LONDON-IOS/GMERemittance/RestApiManager.swift

//
//  RestApiManager.swift
//  GMERemittance
//
//  Created by Sujal on 12/5/17.
//  Copyright © 2017 Gobal Money Express Co. Ltd. All rights reserved.
//

import Foundation
import Alamofire
import SwiftyJSON
import ObjectMapper

enum ApiResult {
    case success(JSON)
    case failure(JSON)
    case updateAccessCode()
    case logOutUser()
    case timeOut()
}

class RestApiMananger {
    
    let manager: SessionManager

    
    static let sharedInstance = RestApiMananger()
    
    init() {
        self.manager = Alamofire.SessionManager.default
        manager.session.configuration.timeoutIntervalForRequest = 1000
        manager.session.configuration.timeoutIntervalForResource = 1000
    }

    func getUUID() -> String {
        
        let uuid = UserDefaults.standard.object(forKey: AppConstants.uuid) as? String
                if uuid != nil {
                    return uuid!
                } else {
                    let uuid = UUID().uuidString
                    UserDefaults.standard.set(uuid, forKey: AppConstants.uuid)
                    return uuid
                }
    }
    
    func getContentHeaderBeforeLogin() -> [String: String] {
        
        return ["Authorization": "Basic " + ("172017F9EC11222E8107142733:QRK2UM0Q" +
            ":" + getUUID()).toBase64(),
                "Content-Type": "application/json"]
    }
    
    func getContentHeaderAfterLogin() -> [String: String] {
        
        let accessCode = UserDefaults.standard.object(forKey: "com.gmeremit.accessCode") as? String
        
        if accessCode != nil {
            return ["Authorization": "Basic " + accessCode!,
                    "Content-Type": "application/json"]
        } else {
            //Just in case access code becomes nil, use some old access code so that the user gets logged out instead of gettting crash
            return ["Authorization": "Basic MDQ4QUNENEYtMzkzQy00MjdBLTk1QjEtQkU4RTI2RTA4OUFFOjFhNjg2MGQ1LWIzZTgtNGUzMy05NGNhLThkZTA0YTQ5OTc0Mw==",
                    "Content-Type": "application/json"]
        }
    }
    
    
    
    
    
    // ccr
    
    //    added failure for delete operation. check if code is 204. if show show successfull message even in error
    func request<T: Mappable>(method: HTTPMethod, url: String, params: [String: Any]?, encoding: ParameterEncoding = JSONEncoding.default, needsAuthorization: Bool = true,  success: @escaping (T) -> (), failure: @escaping (Error) -> ()) {
        if NetworkReachabilityManager()?.isReachable ?? false {
            let header = needsAuthorization ? getContentHeaderAfterLogin() : getContentHeaderBeforeLogin()
            manager.request(
                url,
                method: method,
                parameters: params,
                encoding: encoding,
                headers: header
                ).handle(success: success, failure: failure)
        }else {
            let error = NSError.init(domain: "NETWORK_REACHABILITY_DOMAIN", code: 0, userInfo: [NSLocalizedDescriptionKey : "No Internet connection found. 
Check your connection."])
            failure(error)
        }
    }
    
    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) -> ()) {
        
        if NetworkReachabilityManager()?.isReachable == true {
                let headers = needsAuthorization ? getContentHeaderAfterLogin() : getContentHeaderBeforeLogin()
                
                self.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: headers,
                    encodingCompletion: { encodingResult in
                        switch encodingResult {
                        case .success(let upload, _, _):
                            upload.handle(success: success, failure: failure)
                        case .failure(let encodingError):
                            let error = NSError.init(domain: "NETWORK_REACHABILITY_DOMAIN", code: 0, userInfo: [NSLocalizedDescriptionKey : "No Internet connection found. 
Check your connection."])
                            failure(error)
                            
                        }
                }
                )
            
        }else {
            let error = NSError.init(domain: "NETWORK_REACHABILITY_DOMAIN", code: 0, userInfo: [NSLocalizedDescriptionKey : "No Internet connection found. 
Check your connection."])
            failure(error)
        }
    }
    
    
    // ccr
    
    
    //Signing up a new user
    func registerUser(userId: String, password: String, completion: @escaping (ApiResult) -> Void) {
        manager.request(
            URL(string: UrlManager.sharedInstance.getSignupURL())!,
            method: .post,
            parameters: ["userId": userId, "password" : password],
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    completion(.failure(JSON(response.data!)))
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //Verification of 4 digit code for
    func authenticateUser(code: String, userId: String, completion: @escaping (ApiResult) -> Void) {
    
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getCodeVerificationURL(userId: userId))!,
            method: .post,
            parameters: ["verificationcode": code, "phoneOs": "ios"],
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 204) else { //initially 204
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else {
                        
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                
                completion(.success(JSON.null))
        }
    }
    
    //Requesting another access code
    func requestAnotherCode (type: String, userId: String, completion: @escaping (ApiResult) -> Void) {
        
        var param: [String: String]?
        
        switch type {
        case "device":
            param = ["codeType":"dvc"]
        case "password":
            param = ["codeType":"prc"]
        default:
            param = nil
        }

        
        manager.request(
            URL(string: UrlManager.sharedInstance.getRequestAnotherCodeURL(userId: userId))!,
            method: .post,
            parameters: param!,
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    }else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    

    
    //Checking user verification for password reset process, 1 of 3
    func isVerifiedUser(userId: String, completion: @escaping (ApiResult) -> Void) {
    
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getUserVerificationURLforPasswordReset())!,
            method: .post,
            parameters: ["userId": userId],
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    }else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    func submitUserDOB(userId: String, userDOB: String, completion: @escaping (ApiResult) -> Void) {
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getDOBVerificationURLforPasswordReset(userId: userId))!,
            method: .post,
            parameters: ["userId": userId, "answer": userDOB],
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    //Getting 4 digit code for password reset, 3 of 3
    func reAuthenticateUser(code: String, userId: String, completion: @escaping (ApiResult) -> Void) {
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getResetCodeValidationURL(userId: userId))!,
            method: .post,
            parameters: ["forgetCode": code, "phoneOs": "ios"],
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    }else{
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //Resetting password
    func resetPassword(userId: String, password: String, completion: @escaping (ApiResult) -> Void) {

        
        manager.request(
            URL(string: UrlManager.sharedInstance.getPasswordUpdateURL(userId: userId))!,
            method: .patch,
            parameters: ["password": password],
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    }else{
                        completion(.failure(JSON(response.data!)))
                    }
                    
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    // Getting recipients as per pagination
    func fetchRecipientListThroughPagination(userId: String, page: Int, size: Int, completion: @escaping (ApiResult) -> Void){
        
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getRecipientListURLForPagination())!,
            method: .get,
            parameters: ["userId":userId,"size":size,"page":page],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error 
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                        
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //Creating a new recipient
    func createNewRecipient(recipientDetails: [String: String], completion: @escaping (ApiResult) -> Void) {
        
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getNewRecipientURL())!,
            method: .post,
            parameters: recipientDetails,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
             
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
              completion(.success(JSON(response.data!)))
        }
    }
    
    //Updating a recipient
    func updateRecipient(recipientId: String, recipientDetails: [String: String], completion: @escaping (ApiResult) -> Void) {
       
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getUpdateRecipientURL(recipientId: recipientId))!,
            method: .patch,
            parameters: recipientDetails,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    //Removing an existing recipient
    func deleteRecipient(recipientId: String, completion: @escaping (ApiResult) -> Void) {
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getDeleteRecipientURL(recipientId: recipientId))!,
            method: .delete,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                    completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 204) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    
    
    func updateAccessCode(userId: String,password:String,completion: @escaping (String) -> Void) {
        
       Alamofire.request(
            URL(string: UrlManager.sharedInstance.getLogInURL())!,
            method: .post,
            parameters: ["userId": userId, "password": password],
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
               
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                   completion("Error")
                    return
                }
               var json = JSON(response.data!)
               completion(json["accessCode"].stringValue)
        }
    }
    
    /*  Recipient Model */
    
    //Getting transaction Information on send money and wallet
    func getTransactionInfo(param: [String: String],completion: @escaping (ApiResult) -> Void) {
        
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getTransactionInformationURL())!,
            method: .get,
            parameters: param,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getCurrency(param: [String: String],completion: @escaping (ApiResult) -> Void) {
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getCurrencyURL())!,
            method: .get,
            parameters: param,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //Recharging mobile
    func rechargeMobile(rechargeDetails: [String: String], completion: @escaping (ApiResult) -> Void) {
        
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getRechargeURL())!,
            method: .post,
            parameters: rechargeDetails,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                         completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //Recharging amounts for mobile recharge
    func amountsForMobileRecharge(rechargeDetails: [String: String], completion: @escaping (ApiResult) -> Void) {

        manager.request(
            URL(string: UrlManager.sharedInstance.getURLForMobileRechargeAmount())!,
            method: .get,
            parameters: rechargeDetails,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func callMobileOperator(rechargeDetails: [String: String], completion: @escaping (ApiResult) -> Void) {
        
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getMobileOperator())!,
            method: .get,
            parameters: rechargeDetails,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //Getting Bank Details
    func getBankDetails(completion: @escaping (ApiResult) -> Void) {
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getBankDetailsURL())!,
            method: .get,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getSource(completion: @escaping (ApiResult) -> Void) {
        
        
        Alamofire.request(
            URL(string: UrlManager.sharedInstance.getSourceURL())!,
            method: .post,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getTransferReason(completion: @escaping (ApiResult) -> Void) {
        
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getTransferReasonURL())!,
            method: .post,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func performTransfer(parameters: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getTransferURL())!,
            method: .post,
            parameters: parameters,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    
                    return
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getCDDListFor(cddCode: String, param: [String: String]?, completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getCDDURL(code: cddCode))!,
            method: .get,
            parameters: param,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    
                    if response.response?.statusCode == 401{
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else if (response.error != nil)  {
                        completion(.failure(JSON(response.data!)))
                    }else{
                        if response.result.isFailure{
                            completion(.timeOut())
                        }
                    }
                    return
                }
                
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    func submitKYCInfo(param: [String: String], userId: String, completion: @escaping (ApiResult) -> Void) {
        
 
        
        
        Alamofire.request(
            URL(string: UrlManager.sharedInstance.getKycURL(userId: userId))!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 201) else {
                    
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
                return
        }
    }
    
    func submitDocument(param: [String: String], userId: String, completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getKycDocumentURL(userId: userId))!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 201) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    func submitUserImage(param: [String: String], userId: String, completion: @escaping (ApiResult) -> Void) {
        
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getUserProfileURL(userId: userId))!,
            method: .patch,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderBeforeLogin()
            ).responseJSON { (response) -> Void in
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func  getUserDetails(userId: String, completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getUserProfileURL(userId: userId))!,
            method: .get,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                
                guard (response.response?.statusCode == 200) else {
                   
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    
                    return
                }
               completion(.success(JSON(response.data!)))
        }
        
    }
    
    func fetchUserInfoFromKyc(userId: String, completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getKYCURL(userId: userId))!,
            method: .get,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
            completion(.success(JSON(response.data!)))
        }
    }
    
    func updateUserInfoForKyc(userId: String, parameter: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            
            URL(string: UrlManager.sharedInstance.getKYCURL(userId: userId))!,
            method: .patch,
            parameters: parameter,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error 
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    /// Getting AgentLocation
    func getAgentLocationDetails(countryId: String, city: String,completion: @escaping (ApiResult) -> Void) {
        
        let sessionManager = Alamofire.SessionManager.default
        sessionManager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
            dataTasks.forEach { $0.cancel() }
            uploadTasks.forEach { $0.cancel() }
            downloadTasks.forEach { $0.cancel() }
        }
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getPayoutsURL())!,
            method: .get,
            parameters: ["countryId": countryId, "city": city, "constraint": "default"],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error 
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    func getFilteredRecipientList(queryString: String, userId: String, completion: @escaping (ApiResult) -> Void) {

        cancelExistingNetworkCalls()

 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getRecipientListURL(userId: userId))!,
            method: .get, parameters: ["search": queryString],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getTransactionList(userId: String, recipientId: String, recipientName: String, transactionType: String, startDate: String, endDate: String, txPage: String, txSize: String, completion: @escaping (ApiResult) -> Void) {
        
        var parameters: [String: Any] = [String: Any] ()
        
        switch transactionType {
        case "":
            parameters = ["userId": userId, "startDate": startDate, "endDate": endDate]
            
        case "sent":
            parameters = ["userId": userId, "transactionType": "sent", "startDate": startDate, "endDate": endDate]
            
        case "received":
            parameters = ["userId": userId, "transactionType": "received", "startDate": startDate, "endDate": endDate]
            
        case "date" :
            parameters = ["userId": userId, "startDate": startDate, "endDate": endDate]
            
        case "trackTransfer":
            parameters = ["size": 3, "userId": userId, "receiverId": recipientId, "startDate": startDate, "endDate": endDate, "payoutMode": "cash,bank,door to door"]
            
        case "search":
            parameters = ["userId": userId, "search": recipientName, "startDate": startDate, "endDate": endDate]
            
        case "walletTransfer":
            parameters = ["page": txPage, "size": txSize, "startDate": startDate, "endDate": endDate, "userId": userId, "transactionType": "sent", "payoutMode": "wallet transfer"]
            
        case "walletBorrow":
            parameters = ["page": txPage, "size": txSize, "startDate": startDate, "endDate": endDate, "requestedTo": userId, "payoutMode": "wallet transfer", "transferType": "request"]
            
        case "moneyRequest":
            parameters = ["page": txPage, "size": txSize, "startDate": startDate, "endDate": endDate, "payoutMode": "wallet transfer", "transferType": "request", "userId": userId]
            
        default:
            return
        }
        
 

        manager.request(
            URL(string: UrlManager.sharedInstance.getTransactionListURL())!,
            method: .get,parameters: parameters, encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    /**
     TrackTransaction Pagination
     */
    func getTransactionList(userId: String, recipientId: String, recipientName: String, transactionType: String, startDate: String, endDate: String, page:Int, size: Int, completion: @escaping (ApiResult) -> Void) {
        
        var parameters: [String: Any] = [String: Any] ()
        
        switch transactionType {
        case "":
            parameters = ["userId": userId, "startDate": startDate, "endDate": endDate, "page": page, "size": size]
            
        case "sent":
            parameters = ["userId": userId, "transactionType": "sent", "startDate": startDate, "endDate": endDate,"page": page, "size": size]
            
        case "received":
            parameters = ["userId": userId, "transactionType": "received", "startDate": startDate, "endDate": endDate,"page": page, "size": size]
            
        case "date" :
            parameters = ["userId": userId, "startDate": startDate, "endDate": endDate]
            
        case "trackTransfer":
            parameters = ["size": 3, "userId": userId, "receiverId": recipientId, "startDate": startDate, "endDate": endDate]
            
        case "search":
            parameters = ["userId": userId, "receiverName": recipientName, "startDate": startDate, "endDate": endDate]
            
        case "walletTransfer":
            parameters = ["userId": userId, "payoutMode": "wallet transfer", "transferType": "offer", "startDate": startDate, "endDate": endDate, "page": page, "size": size]
            
        case "walletBorrow":
            parameters = ["userId": userId, "payoutMode": "wallet transfer", "transferType": "request", "startDate": startDate, "endDate": endDate, "page": page, "size": size]
            
        case "moneyRequest":
            parameters = ["requestedTo": userId, "payoutMode": "wallet transfer", "startDate": startDate, "endDate": endDate]
            
        default:
            return
        }
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getTransactionListURL())!,
            method: .get,parameters: parameters, encoding: URLEncoding.queryString,
            
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    func submitMessage(supportIndex: Int, param: [String: String],  completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getMessageURL(supportIndex: supportIndex))!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 201) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    func withdrawBalance(requestDetails: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getWithdrawURL())!,
            method: .post,
            parameters: requestDetails,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    
    func getBranchDetails(bankId: String, completion: @escaping (ApiResult) -> Void) {
        
        let sessionManager = Alamofire.SessionManager.default
        sessionManager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
            dataTasks.forEach { $0.cancel() }
            uploadTasks.forEach { $0.cancel() }
            downloadTasks.forEach { $0.cancel() }
        }
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getBranchURL(bankId: bankId))!,
            method: .get,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    func changePassword(userId: String, currentPassword: String, newPassword: String, completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getPasswordChangeURL(userId: userId))!,
            method: .post,
            parameters: ["currentPassword": currentPassword,
                         "newPassword": newPassword],
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 204) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func performWalletAction(param: [String: String], moneyRequestAccepted: Bool, completion: @escaping (ApiResult) -> Void) {
        let urlString: String!
        if moneyRequestAccepted {
            urlString = UrlManager.sharedInstance.getAcceptMoneyRequestURL()
        } else {
            urlString = UrlManager.sharedInstance.getWalletURL()
        }
        
 
        
        manager.request(
            URL(string: urlString)!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    /// Create Invitee
    func createInvitee(param: [String: String], completion: @escaping (ApiResult) -> Void){
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getNewInviteeURL())!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 201) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
            completion(.success(JSON(response.data!)))
        }
    }
    
    /// GetInvitee
    func getInvitee(userId: String, completion: @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getInviteeURL(userId:userId))!,
            method: .get,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getcmRegistrationId(userId: String, cmRegistrationId: String, completion: @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getcmRegistrationIdURL(userId: userId))!,
            method: .patch,
            parameters: ["cmRegistrationId": cmRegistrationId],
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
        
    }
    
    func getNotification(userId: String, completion: @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getNotificationURL(userId: userId))!,
            method: .get,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getNotification(userId: String,page:Int,size:Int, completion: @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getNotificationURL(userId: userId))!,
            method: .get,
            parameters: ["userId":userId,"size":size,"page":page],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func patchNotification(notificationId: String, viewed: String, completion: @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.patchNotificationURL(notificationId: notificationId))!,
            method: .patch,
            parameters: ["viewed": viewed],
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                
                
                completion(.success(JSON(response.data!)))
        }
    }
    
    func fetchCountryList(completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getCountryURL())!,
            method: .get,
            parameters: nil,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getCountryInfo(countryId:String, completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getCountryURL())!,
            method: .get,
            parameters: ["countryId": countryId],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    
    func getCountryPayoutMode(countryId: String, completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getCountryPayoutModeURL())!,
            method: .get,parameters: ["countryId": countryId],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func fetchAgentLocation(countryId: String,completion: @escaping (ApiResult) -> Void){
 
        manager.request(
            URL(string: UrlManager.sharedInstance.getPayoutsURL())!,
            method: .get,
            parameters: ["countryId": countryId, "constraint": "default"],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getPayoutBankDetail(countryId: String, payoutMethodId: String, completion: @escaping (ApiResult) -> Void){
       
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getPayoutsURL())!,
            method: .get,
            parameters: ["countryId": countryId,"payoutMethodId": payoutMethodId, "constraint": "txn"],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func getPayoutBankBranchDetail(countryId: String, payoutId: String, completion: @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getPayoutsBranchURL(payoutId: payoutId))!,
            method: .get,
            parameters: ["countryId": countryId],
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }

    
    
    //SOCIAL BEGINS HERE
    
    
    //CREATE Social Feeds
    func createSocialFeed(param: [String: String], completion: @escaping (ApiResult) -> Void) {
 
        manager.request(URL(string: UrlManager.sharedInstance.getCRUDFeedURL())!,
                          method: .post,
                          parameters: param,
                          encoding: JSONEncoding.default,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 201) else {
                    if response.response?.statusCode == 401 {
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //READ Social Feeds
    func getSocialFeeds(param : [String: String], completion : @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string : (UrlManager.sharedInstance.getCRUDFeedURL()))!,
            method: .get,
            parameters: param,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                     completion(.timeOut())
                }
                 guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //UPDATE Social Feeds
    func updateSocialFeed(feedId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
        let url = UrlManager.sharedInstance.getCRUDFeedURL() + "/" + feedId
        
 
        
        manager.request(URL(string: url)!,
                          method: .put,
                          parameters: param,
                          encoding: JSONEncoding.default,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
        
    }
    
    //DELETE Social Feeds
    func deleteSocialFeed(feedId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
        let url = UrlManager.sharedInstance.getCRUDFeedURL() + "/" + feedId
        
 
        
        manager.request(URL(string: url)!,
                          method: .delete,
                          parameters: param,
                          encoding: URLEncoding.queryString,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 204) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //DELETE Social Feeds
    func reportSocialFeed(feedId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
        let url = UrlManager.sharedInstance.getCRUDFeedURL() + "/" + feedId + "/reports?"
        
 
        
        manager.request(URL(string: url)!,
                          method: .post,
                          parameters: param,
                          encoding: JSONEncoding.default,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 201) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //Multipart Image Upload
    func uploadImage(imageData: Any, isGif: Bool, param : [String:String], completion : @escaping (ApiResult) -> Void) {
        var fileName: String!
        var mimeType: String!
        var data: Data!
        
        if isGif {
            fileName = "test.gif"
            mimeType = "image/gif"
            data = imageData as! Data
        } else {
            fileName = "test.jpg"
            mimeType = "image/jpeg"
            data = UIImageJPEGRepresentation(imageData as! UIImage, 0.7)!
        }
        
 
        manager.upload(
            multipartFormData: { multipartFormData in
                multipartFormData.append(data, withName: "file", fileName: fileName, mimeType: mimeType)
                for (key,value) in param {
                    multipartFormData.append(value.data(using: .utf8)!, withName: key)
                }
        },
            
            to: URL(string: UrlManager.sharedInstance.multipartImageUploadURL())!,
            method: .post,
            headers: getContentHeaderAfterLogin(),
            encodingCompletion: { encodingResult in
                switch encodingResult {
                case .success(let upload, _, _):
                    upload.responseJSON { response in
                        
                        if let error = response.result.error {
                            if error._code == NSURLErrorTimedOut {
                                completion(.timeOut())
                            }
                        }
                        
                        if response.result.isFailure{
                            completion(.timeOut())
                        }
                        
                        if response.response?.statusCode == nil {
                            return
                        }
                        guard (response.response?.statusCode == 201) else {
                            if response.response?.statusCode == 401 {
                                completion(.updateAccessCode())
                            } else if response.response?.statusCode == 403 {
                                completion(.logOutUser())
                            } else {
                                completion(.failure(JSON(response.data!)))
                            }
                            return
                        }
                        completion(.success(JSON(response.data!)))
                    }
                case .failure(_):
                    return
                    
                }
        })
    }
    
    //LIKE OR DISLIKE Social Feed
    func likeDislikeSocialFeed(feedId: String, isLiked: Bool, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
        var methodType: HTTPMethod!
        
        if isLiked {
            methodType = .delete
        } else {
            methodType = .post
        }
        
 
        
        manager.request(URL(string: UrlManager.sharedInstance.getLikeDislikeFeedURL(feedId: feedId))!,
                          method: methodType,
                          parameters: param,
                          encoding: URLEncoding.queryString,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
               guard response.response?.statusCode != nil else {
                    completion(.timeOut())
                    return
                }
                switch response.response?.statusCode {
                case 204?, 201?:
                    completion(.success(JSON(response.data!)))
                case 401?:
                    completion(.updateAccessCode())
                case 403?:
                    completion(.logOutUser())
                default:
                    completion(.failure(JSON(response.data!)))
                }
            }
    }
    
    //LIKES for Social Feed
    func getAllLikesFor(feedId: String, completion: @escaping (ApiResult) -> Void) {
        
 
        manager.request(URL(string: UrlManager.sharedInstance.getLikeDislikeFeedURL(feedId: feedId))!,
                          method: .get,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    
    //COMMENTS for Social Feed
    func getAllCommentsFor(feedId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(URL(string: UrlManager.sharedInstance.getCommentFeedURL(feedId: feedId))!,
                          method: .get,
                          parameters: param,
                          encoding: URLEncoding.queryString,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    //CREATE NEW COMMENT
    func createComment(feedId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(URL(string: UrlManager.sharedInstance.getCreateCommentURL(feedId: feedId))!,
                          method: .post,
                          parameters: param,
                          encoding: JSONEncoding.default,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 201) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    //EDIT COMMENT
    func editComment(feedId: String, commentId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(URL(string: UrlManager.sharedInstance.getEditDeleteCommentURL(feedId: feedId, commentId: commentId))!,
                          method: .put,
                          parameters: param,
                          encoding: JSONEncoding.default,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                 }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())

                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    //REMOVE COMMENT
    func deleteComment(feedId: String, commentId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(URL(string: UrlManager.sharedInstance.getEditDeleteCommentURL(feedId: feedId, commentId: commentId))!,
                          method: .delete,
                          parameters: param,
                          encoding: URLEncoding.queryString,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }

                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 204) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    //FETCH REWARDS
    func fetchRewards(completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(URL(string: UrlManager.sharedInstance.getRewardsURL())!,
                          method: .get,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
            completion(.success(JSON(response.data!)))
        }
    }
    
    //REDEEM REWARD
    func redeemReward(rewardId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(URL(string: UrlManager.sharedInstance.getRedeemRewardURL(rewardId: rewardId))!,
                          method: .post,
                          parameters: param,
                          encoding: JSONEncoding.default,
                          headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 201) else {
                    if response.response?.statusCode == 401 {
                         completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    

    /**
        GET CURRENCIES
    */
    func getCurrencies(param: [String: String],completion: @escaping (ApiResult) -> Void) {
        
 

        manager.request(
            URL(string: UrlManager.sharedInstance.getCurrencyURL())!,
            method: .get,
            parameters: param,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }

   
    /**
     GET Exchange Rate
     */
    func getExchangeRates(param: [String: Any], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getExchangeRateURL())!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                       completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    
    //UPDATE USER DETAIL (NOT KYC)
    //USE THIS FUNCTION TO UPDATE USER PROFILE IMAGE AND CMREGISTRATION CODE
    func updateUserDetail(userId: String, param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getUserUpdateURL(userId: userId))!,
            method: .patch,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else{
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    func validateReferralCode(param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getReferralCodeValidationURL())!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func rejectMoneyRequest(param: [String: String], completion: @escaping (ApiResult) -> Void) {
        
 
        
        manager.request(
            URL(string: UrlManager.sharedInstance.getRejectMoneyRequestURL())!,
            method: .post,
            parameters: param,
            encoding: JSONEncoding.default,
            headers: getContentHeaderAfterLogin()
            ).responseJSON { (response) -> Void in
                
                if let error = response.result.error {
                    if error._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                    return
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401{
                       completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
               completion(.success(JSON(response.data!)))
        }
    }
    
    
    
    func getParticularSocialFeed(feedId: String, param : [String: String], completion : @escaping (ApiResult) -> Void){
        
 
        
        manager.request(
            URL(string : (UrlManager.sharedInstance.getParticularFeedURL(feedId: feedId)))!,
            method: .get,
            parameters: param,
            encoding: URLEncoding.queryString,
            headers: getContentHeaderAfterLogin())
            .responseJSON { (response) -> Void in
                
                let error = response.result.error
                    if error?._code == NSURLErrorTimedOut {
                        completion(.timeOut())
                    }
                
                if response.result.isFailure{
                    completion(.timeOut())
                }
                
                if response.response?.statusCode == nil {
                     completion(.timeOut())
                }
                guard (response.response?.statusCode == 200) else {
                    if response.response?.statusCode == 401 {
                        completion(.updateAccessCode())
                    } else if response.response?.statusCode == 403 {
                        completion(.logOutUser())
                    } else {
                        completion(.failure(JSON(response.data!)))
                    }
                    return
                }
                completion(.success(JSON(response.data!)))
        }
    }
    
    func cancelExistingNetworkCalls() {
        let sessionManager = Alamofire.SessionManager.default
        sessionManager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
            dataTasks.forEach { $0.cancel() }
            uploadTasks.forEach { $0.cancel() }
            downloadTasks.forEach { $0.cancel() }
        }
    }
    
}