ThirdPartyAPI/Transfast/ApiServices/TFAPI.cs

using Common.Models;
using Common.Models.Address;
using Common.Models.Bank;
using Common.Models.ExchangeRate;
using Common.Models.Payer;
using Common.Models.RequestResponse;
using Common.Models.Sender;
using Common.Models.Status;
using Common.Models.TxnAmendModel;
using Common.Models.TxnModel;
using Common.TPService;
using Common.Utility;
using log4net;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using Transfast.Model.Address.City;
using Transfast.Model.Address.State;
using Transfast.Model.Address.Town;
using Transfast.Model.Bank;
using Transfast.Model.BankBranch;
using Transfast.Model.Compliance;
using Transfast.Model.ExRate;
using Transfast.Model.Payers;
using Transfast.Model.PaymenType;
using Transfast.Model.Receiver;
using Transfast.Model.Sender;
using Transfast.Model.SendTxn;
using Transfast.Model.SendTxn.TxnCancel;
using Transfast.Model.TransactionInfo;

namespace Transfast.ApiServices
{
    public class TFAPI : ITPApiServices
    {
        private readonly ILog _log = LogManager.GetLogger(typeof(TFAPI));
        private readonly string userName;
        private readonly string password;
        private readonly string branchId;
        private readonly string publicKey;
        private readonly string ft_base_url;
        private readonly string systemId;
        //private readonly string branchIdBank;
        //private readonly string partnerId;
        //private readonly string userNameBank;
        //private readonly string passwordBank;

        public TFAPI()
        {
            userName = GetStatic.ReadWebConfig("transfast_userName", "");
            password = GetStatic.ReadWebConfig("transfast_password", "");
            branchId = GetStatic.ReadWebConfig("transfast_branchId", "");
            publicKey = GetStatic.ReadWebConfig("transfast_publicKey", "");
            ft_base_url = GetStatic.ReadWebConfig("transfast_baseUrl", "");
            systemId = GetStatic.ReadWebConfig("transfast_systemId", "");
            //partnerId = GetStatic.ReadWebConfig("transfast_branchMapCode", "");
            //branchIdBank = GetStatic.ReadWebConfig("transfast_branchId_bank", "");
            //userNameBank = GetStatic.ReadWebConfig("transfast_userName_bank", "");
            //passwordBank = GetStatic.ReadWebConfig("transfast_password_bank", "");
        }
        public TPResponse GetTPResponse<T>(T model, string MethodName) where T : class
        {
            switch (MethodName)
            {
                case "send":
                    return SendTransaction(model as SendTransaction);

                case "release":
                    return ReleseTrasaction(model as TFReleaseTxnRequest);

                case "status":
                    return GetTransactionByPIN(model as GetStatus);

                case "exRate":
                    return GetExRate(model as ExchangeRate);

                case "address":
                    return GetAddress(model as AddressRequest);

                case "bankList":
                    return GetBankList(model as BankRequest);

                case "cancelSend":
                    return CancelTransaction(model as CancelTxn);

                case "senderinfo":
                    return TFSenderInformation(model as SenderRequest);

                case "staticData":
                    return GetStaticData(model as StaticData);

                case "payer":
                    return PayersInformation(model as PayerRequest);

                case "amendment":
                    return AmendTransaction(model as AmendTransaction);

                default:
                    return new TPResponse() { ResponseCode = "1", Msg = "Method Name Not Found !" };
            }
        }

        public TPResponse GetStaticData(StaticData data)
        {
            string url = "";
            string method = "";
            if (data.Type == "POR")
            {
                url = "api/catalogs/remittancepurposes?countryisocode=" + data.CountryIsoCode;
                method = "get";
            }
            TPResponse response = GetRestApiUrl<string, _tpPOR, _tpPOR>(null, url, method, "RemittancePurposes");
            return response;
        }

        private TPResponse TFSenderInformation(SenderRequest sender)
        {
            TFSenderRequest tfSender = ConvertSenderToTFSender(sender);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfSender);
            if (_response == null)
            {
                _response = new TPResponse();
                if (sender.MethodType.ToLower() == "create")
                    _response = GetRestApiUrl<TFSenderRequest, TFSenderResponse, TFSenderResponse>(tfSender, "api/transaction/sender");
                else if (sender.MethodType.ToLower() == "update")
                    _response = GetRestApiUrl<TFSenderRequest, TFSenderResponse, TFSenderResponse>(tfSender, "api/transaction/senderinfo", "put");
                else if (sender.MethodType == "getdetails")
                    _response = GetRestApiUrl<string, TFSenderResponse, TFSenderResponse>(null, "api/transaction/senderbyid?SenderId=" + tfSender.SenderId, "get");

                if (_response.ResponseCode != "0")
                    _log.ErrorFormat("Error occured on TFSenderInformation at transfast api ! Response : ", _response);
                else
                {
                    _log.ErrorFormat("TFSenderInformation success at transfast api ! Response : ", _response);
                }
            }
            return _response;
        }

        private TPResponse GetExRate(ExchangeRate eR)
        {
            TFExRateRequest tfExRate = ConvertExchangeRateModelToTFExRateRequest(eR);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfExRate);

            if (!string.IsNullOrEmpty(eR.ProcessFor))
            {
                if (eR.ProcessFor.ToLower() == "all")
                    return ExRateForAllPayers(tfExRate, eR.PCurrency);
            }

            if (_response == null)
            {
                _response = new TPResponse();
                string _url = "api/rates/countryrates?receivecountryisocode=" + tfExRate.ReceiveCountryIsoCode + "&sourcecurrencyisocode=" + tfExRate.SourceCurrencyIsoCode;
                _response = GetRestApiUrl<string, _ExRateResponse, _ExRateResponse>(null, _url, "get", "Rates");
                var Respp = JsonConvert.SerializeObject(_response);
                if (!string.IsNullOrEmpty(eR.RequestedBy))
                {

                    _log.Info("RequestedBy" + "| " + eR.RequestedBy);
                    if (eR.RequestedBy == "scheduler" && string.IsNullOrEmpty(eR.PaymentType))
                    {
                        return GetExRateForScheduler(_response, eR.PCurrency);
                    }

                    if (eR.RequestedBy == "online" && eR.UserName == "onlinedefault" && eR.PCountryName.ToLower() == "india"
                            && eR.PaymentType.ToUpper() == "CASH PAYMENT")
                    {
                        eR.payerName = "TRANSFAST CASH PICKUP|ID02";
                    }
                    if (eR.RequestedBy == "online" && eR.UserName == "onlinedefault" && eR.PCountryName.ToLower() == "bangladesh"
                           && eR.PaymentType.ToUpper() == "CASH PAYMENT")
                    {
                        eR.payerName = "TRANSFAST CASH PICKUP ANYWHERE|BA99";
                    }
                    if (eR.RequestedBy == "online" && eR.UserName == "onlinedefault" && eR.PCountryName.ToLower() == "bangladesh"
                        && eR.PaymentType.ToUpper() == "BANK DEPOSIT")
                    {
                        eR.payerName = "TRANSFAST BANK DEPOSIT|BA98";
                    }

                }

            

                if (eR.PCountryName.ToLower() == "bangladesh" && eR.PaymentType.ToUpper() == "CASH PAYMENT")
                {
                    eR.payerName = "TRANSFAST CASH PICKUP ANYWHERE|BA99";
                }
                if (eR.PCountryName.ToLower() == "bangladesh" && eR.PaymentType.ToUpper() == "BANK DEPOSIT")
                {
                    eR.payerName = "TRANSFAST BANK DEPOSIT|BA98";
                }

                _log.Info("payerName" + "| " + eR.payerName);

                if (_response.ResponseCode != "0")
                    _log.ErrorFormat("Error occured on GETEXRATE at transfast api ! Response : ", _response);
                else
                {
                    List<TFExRateResponse> data = (List<TFExRateResponse>)_response.Data;

                    data = data.Where(whr => whr.ReceiveCurrencyIsoCode == eR.PCurrency).ToList();

                    string payer = string.IsNullOrEmpty(eR.payerName) ? "" : eR.payerName.Split('|')[1].ToString().TrimStart().TrimEnd().ToUpper();

                    _log.Info("payer" + "| " + payer);

                    TFExRateResponse AgentFilterData = data.FirstOrDefault(x => x.ReceiveCurrencyIsoCode == eR.PCurrency && x.PayerId.ToUpper() == payer);
                    _log.Info("AgentFilterData" + "| " + JsonConvert.SerializeObject(AgentFilterData));
                    if (AgentFilterData != null)
                    {
                        ExRateResponse exRate = new ExRateResponse()
                        {
                            bankName = AgentFilterData.PayerName,
                            exRate = AgentFilterData.StartRate.ToString(),
                            tpExRate = AgentFilterData.EndRate.ToString(),
                            AgentRefId = AgentFilterData.PayerId,
                            tpPCurr = AgentFilterData.ReceiveCurrencyIsoCode
                        };
                        _response.Data = exRate;
                    }
                    else
                    {
                        TFExRateResponse firstData = new TFExRateResponse();
                        if (string.IsNullOrEmpty(eR.PaymentType))
                        {
                            firstData = data.FirstOrDefault(x => x.ReceiveCurrencyIsoCode == eR.PCurrency);
                            if (firstData != null)
                            {
                                ExRateResponse exRate = new ExRateResponse()
                                {
                                    bankName = firstData.PayerName,
                                    exRate = firstData.StartRate.ToString(),
                                    tpExRate = firstData.EndRate.ToString(),
                                    AgentRefId = firstData.PayerId,
                                    tpPCurr = firstData.ReceiveCurrencyIsoCode
                                };
                                _response.Data = exRate;
                            }
                        }
                        else
                        {
                            if (eR.PaymentType.ToUpper() == "CASH PAYMENT")
                                firstData = data.FirstOrDefault(x => x.ReceiveCurrencyIsoCode == eR.PCurrency && (x.ModeOfPaymentName == eR.PaymentType || x.ModeOfPaymentName.ToUpper() == "CASH PICK UP"));
                            else
                                firstData = data.FirstOrDefault(x => x.ReceiveCurrencyIsoCode == eR.PCurrency && x.ModeOfPaymentName == eR.PaymentType);

                            if (firstData != null)
                            {
                                ExRateResponse exRate = new ExRateResponse()
                                {
                                    bankName = firstData.PayerName,
                                    exRate = firstData.StartRate.ToString(),
                                    tpExRate = firstData.EndRate.ToString(),
                                    AgentRefId = firstData.PayerId,
                                    tpPCurr = firstData.ReceiveCurrencyIsoCode
                                };
                                _response.Data = exRate;
                            }
                            else
                            {
                                TFExRateResponse firstData1 = data.FirstOrDefault(x => x.ReceiveCurrencyIsoCode == eR.PCurrency);
                                if (firstData1 != null)
                                {
                                    ExRateResponse exRate = new ExRateResponse()
                                    {
                                        bankName = firstData1.PayerName,
                                        exRate = firstData1.StartRate.ToString(),
                                        tpExRate = firstData1.EndRate.ToString(),
                                        AgentRefId = firstData1.PayerId,
                                        tpPCurr = firstData1.ReceiveCurrencyIsoCode
                                    };
                                    _response.Data = exRate;
                                }
                            }
                        }
                    }
                }
            }
            return _response;
        }

        private TPResponse ExRateForAllPayers(TFExRateRequest tfExRate, string pCurrency)
        {
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfExRate);

            if (_response == null)
            {
                _response = new TPResponse();
                string _url = "api/rates/countryrates?receivecountryisocode=" + tfExRate.ReceiveCountryIsoCode + "&sourcecurrencyisocode=" + tfExRate.SourceCurrencyIsoCode;
                _response = GetRestApiUrl<string, _ExRateResponse, _ExRateResponse>(null, _url, "get", "Rates");

                if (_response.ResponseCode != "0")
                    _log.ErrorFormat("Error occured on GETEXRATE at transfast api ! Response : ", _response);
                else
                {
                    List<TFExRateResponse> data = (List<TFExRateResponse>)_response.Data;
                    List<ExRateResponse> _exRateResponse = new List<ExRateResponse>();

                    List<TFExRateResponse> result = new List<TFExRateResponse>();

                    if (pCurrency == "BDT")
                    {
                        List<string> BDTpayers = new List<string>() { "BA99", "BA98" };
                        result = data.Where(whr => whr.ReceiveCurrencyIsoCode == pCurrency && BDTpayers.Contains(whr.PayerId)).ToList();
                    }                   

                    foreach (var item in result)
                    {
                        ExRateResponse exRate = new ExRateResponse()
                        {
                            bankName = item.PayerName,
                            exRate = item.StartRate.ToString(),
                            tpExRate = item.EndRate.ToString(),
                            AgentRefId = item.PayerId,
                            tpPCurr = item.ReceiveCurrencyIsoCode,
                            ModeOfPaymentName = item.ModeOfPaymentName
                        };

                        _exRateResponse.Add(exRate);
                    }
                    _response.Data = _exRateResponse;
                }
            }
            return _response;
        }

        private TPResponse GetExRateForScheduler(TPResponse response, string PCurrency)
        {
            TPResponse _response = new TPResponse();
            List<TFExRateResponse> data = (List<TFExRateResponse>)response.Data;


            TFExRateResponse firstData1 = data.FirstOrDefault(x => x.ReceiveCurrencyIsoCode == PCurrency);
            if (firstData1 != null)
            {
                ExRateResponse exRate = new ExRateResponse()
                {
                    bankName = firstData1.PayerName,
                    exRate = firstData1.StartRate.ToString(),
                    tpExRate = firstData1.EndRate.ToString(),
                    AgentRefId = firstData1.PayerId,
                    tpPCurr = firstData1.ReceiveCurrencyIsoCode
                };
                _response.Data = exRate;
            }
            return _response;
        }

        private TPResponse GetState(string countryIso)
        {
            TPResponse _response = new TPResponse();
            _response = GetRestApiUrl<string, _States, _States>(null, "api/catalogs/states?countryisocode=" + countryIso, "get", "States");

            if (_response.ResponseCode != "0")
                _log.ErrorFormat("Error occured on GetState at transfast api ! Response : ", _response);
            else
            {
                _log.ErrorFormat("GetState success at transfast api ! Response : ", _response);
            }
            return _response;
        }

        private TPResponse GetAddress(AddressRequest tF)
        {
            switch (tF.MethodType)
            {
                case "city":
                    return GetCities(tF);

                case "state":
                    return GetState(tF.CountryIsoCode);

                case "town":
                    return GetTown(tF);

                case "paymentType":
                    return GetPaymentMode(tF);

                default:
                    return new TPResponse() { ResponseCode = "1", Msg = "Address Type Not Found !" };
            }
        }

        private TPResponse GetCities(AddressRequest tF)
        {
            TPResponse _response = new TPResponse();
            _response = GetRestApiUrl<string, _Cities, _Cities>(null, "api/catalogs/cities?countryisocode=" + tF.CountryIsoCode + "&stateid=" + tF.StateId, "get", "Cities");

            if (_response.ResponseCode != "0")
                _log.ErrorFormat("Error occured on GETCITIES at transfast api ! Response : ", _response);
            else
                _log.ErrorFormat("GETCITIES success at transfast api ! Response : ", _response);
            return _response;
        }

        private TPResponse GetTown(AddressRequest tF)
        {
            TPResponse _response = new TPResponse();
            _response = GetRestApiUrl<string, _Towns, _Towns>(null, "api/catalogs/towns?countryisocode=" + tF.CountryIsoCode + "&stateid=" + tF.StateId + "&cityId=" + tF.CityId, "get", "Towns");

            if (_response.ResponseCode != "0")
                _log.ErrorFormat("Error occured on GETTOWN at transfast api ! Response : ", _response);
            else
                _log.ErrorFormat("GETTOWN success at transfast api ! Response : ", _response);
            return _response;
        }

        private TPResponse GetPaymentMode(AddressRequest tF)
        {
            TPResponse _response = new TPResponse();
            _response = GetRestApiUrl<string, _PaymentType, _PaymentType>(null, "api/catalogs/paymentmodes?countryisocode=" + tF.CountryIsoCode + "&cityId=" + tF.CityId, "get", "PaymentModes");

            if (_response.ResponseCode != "0")
                _log.ErrorFormat("Error occured on GETPAYMENTMODE at transfast api ! Response : ", _response);
            else
                _log.ErrorFormat("GETPAYMENTMODE success at transfast api ! Response : ", _response);
            return _response;
        }

        private TPResponse GetTransactionByPIN(GetStatus getStatus)
        {
            string getTranUrl = "ByReferenceNo?ReferenceNumber=" + getStatus.ControlNo;
            if (!string.IsNullOrEmpty(getStatus.PartnerPinNo) && !string.IsNullOrWhiteSpace(getStatus.PartnerPinNo))
                getTranUrl = "bytfpin?TfPin=" + getStatus.PartnerPinNo;

            TPResponse _rsponse = GetRestApiUrl<string, TFSendTxnResponse, TFSendTxnResponse>(null, "api/transaction/" + getTranUrl, "get");

            if (_rsponse.ResponseCode != "0")
                _log.ErrorFormat("Error occured on GETTRANSACTIONBYPIN at transfast api ! Response : ", _rsponse);
            else
                _log.ErrorFormat("GETTRANSACTIONBYPIN success at transfast api ! Response : ", _rsponse);

            return _rsponse;
        }

        private TPResponse SendTransaction(SendTransaction sT)
        {
            var tfSendModel = ConvertSendTransactionModelToTFSendTxtnRequest(sT);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfSendModel);
            _log.DebugFormat(GetStatic.ConvertToJson(tfSendModel));
            if (_response == null)
            {
                _response = GetRestApiUrl<TFSendTxtnRequest, TFSendTxnResponse, TFSendTxnFailedResponse>(tfSendModel, "api/transaction/invoice");
                if (_response.ResponseCode == "0")
                {
                    PropertyInfo tfPin = _response.Data.GetType().GetProperty("TfPin");
                    string tfPinValue = (string)tfPin.GetValue(_response.Data, null);
                    PropertyInfo TransactionInfo = _response.Data.GetType().GetProperty("TransactionInfo");
                    object trasactionData = TransactionInfo.GetValue(_response.Data, null);
                    PropertyInfo refNo = trasactionData.GetType().GetProperty("ReferenceNumber");
                    _response.Extra = tfPinValue;
                    _response.Id = (string)refNo.GetValue(trasactionData, null);
                    _response.Msg = "Transaction Send Successfully For Transfast With Control No = " + sT.Transaction.JMEControlNo + " And Response Control No = " + tfPinValue;
                }
            }
            return _response;
        }

        private TPResponse ReleseTrasaction(TFReleaseTxnRequest tfPINNo)
        {
            return GetRestApiUrl<TFReleaseTxnRequest, string, TFSendTxnFailedResponse>(tfPINNo, "api/transaction/release", "put");
        }

        private TPResponse CancelTransaction(CancelTxn txn)
        {
            TFTxnCancelRequest tfSendModel = ConvertToTFTxnCancelRequest(txn);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfSendModel);
            if (_response == null)
            {
                _response = new TPResponse();
                _response = GetRestApiUrl<TFTxnCancelRequest, string, TFSendTxnFailedResponse>(tfSendModel, "api/transaction/cancel", "put");
                if (_response.ResponseCode != "0")
                    _log.ErrorFormat("Error occured on CancelTransaction at transfast api ! Response : ", _response);
                else
                    _log.ErrorFormat("CancelTransaction process success at transfast api ! Response : ", _response);
            }
            return _response;
        }
        private TPResponse AmendTransaction(AmendTransaction aTxn)
        {
            var tfAmendModel = ConvertAmendTransactionModelToTFAmendTxtnRequest(aTxn);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfAmendModel);
            _log.DebugFormat(GetStatic.ConvertToJson(tfAmendModel));
            if (_response == null)
            {
                _response = GetRestApiUrl<TFAmendTxnRequest, string, TFSendTxnFailedResponse>(tfAmendModel, "api/transaction/invoice", "put");
                if (_response.ResponseCode != "0")
                {
                    if (_response.Msg.Split(':')[1].ToString().ToLower() != "notfound")
                    {
                        PropertyInfo businessError = _response.Data.GetType().GetProperty("BusinessErrors");
                        List<BusinessError> businessErrorData = (List<BusinessError>)businessError.GetValue(_response.Data, null);
                        string msg = "";
                        if (businessErrorData.Count > 0)
                        {
                            foreach (BusinessError item in businessErrorData)
                            {
                                msg += item.Message + "     ";
                            }
                        }
                        PropertyInfo validationError = _response.Data.GetType().GetProperty("DataValidationErrors");
                        List<DataValidationError> validationErrorData = (List<DataValidationError>)validationError.GetValue(_response.Data, null);
                        if (validationErrorData.Count > 0)
                        {
                            foreach (DataValidationError item in validationErrorData)
                            {
                                msg += item.Message + "    ";
                            }
                        }
                        _response.Msg += msg;
                    }
                    _log.ErrorFormat("Error occured on AMENDTRANSACTION at transfast api ! Response : ", _response);
                }
                else
                {
                    _response.Extra = aTxn.TfPinno;
                    _response.Id = aTxn.TfPinno;
                    _response.Msg = "Transaction Amended Successfully For Transfast With Control No = " + aTxn.TfPinno;
                    //_response = GetRestApiUrl<TFReleseTxnRequest, string>(new TFReleseTxnRequest() { TfPin = (string)tfPin.GetValue(_response.Data, null) }, "api/transaction/release", "put");
                    _log.ErrorFormat("AMENDTRANSACTION process success at transfast api ! Response : ", _response);
                }
            }
            return _response;
        }

        private TPResponse GetBankList(BankRequest bank)
        {
            if (bank.IsBranch)
            {
                return GetBankBranchList(bank);
            }
            var tfBank = ConvetToTFBankRequest(bank);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfBank);
            if (_response == null)
            {
                _response = new TPResponse();
                _response = GetRestApiUrl<string, _TFBank, _TFBank>(null, "api/catalogs/banks?countryisocode=" + tfBank.CountryIsoCode, "get", "Banks");
                if (_response.ResponseCode != "0")
                    _log.ErrorFormat("Error occured on GetBankList at transfast api ! Response : ", _response);
                else
                    _log.ErrorFormat("GetBankList process success at transfast api ! Response : ", _response);
            }
            return _response;
        }

        private TPResponse GetBankBranchList(BankRequest bank)
        {
            TFBankBranchRequest tfBank = ConvetToTFBankBranchRequest(bank);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tfBank);
            if (_response == null)
            {
                _response = new TPResponse();
                _response = GetRestApiUrl<string, List<TFBankBranchResponse>, string>(null, "api/catalogs/BankBranch?BankId=" + tfBank.BankId + "&CityID=" + tfBank.CityId, "get");
                if (_response.ResponseCode != "0")
                    _log.ErrorFormat("Error occured on GetBankBranchList at transfast api ! Response : ", _response);
                else
                    _log.ErrorFormat("GetBankBranchList process success at transfast api ! Response : ", _response);
            }
            return _response;
        }

        private TPResponse PayersInformation(PayerRequest pR)
        {
            TFPayersRequest tf = ConvertToTFPayersRequest(pR);
            TPResponse _response = new CustomModelValidaton().IsModelValid(tf);
            if (_response == null)
            {
                _response = new TPResponse();
                var url = "api/catalogs/payers?countryisocode=" + tf.CountryIsoCode + "&cityid=" + tf.CityId +
                           "&paymentmodeid=" + tf.PaymentModeId + "&sourcecurrencyisocode=" + tf.SourceCurrencyIsoCode + "&receivecurrencyisocode=" +
                           tf.ReceiveCurrencyIsoCode + "&BankID=" + tf.BankId;
                _response = GetRestApiUrl<string, _MasterResults, _MasterResults>(null, url, "get", "MasterPayerResults");
                if (_response.ResponseCode != "0")
                    _log.ErrorFormat("Error occured on PayersInformation at transfast api ! Response : ", _response);
                else
                    _log.ErrorFormat("PayersInformation process success at transfast api ! Response : ", _response);
            }
            return _response;
        }

        private TPResponse GetRestApiUrl<RequestModel, ResponseModelForSucess, ResponseModelForFailed>(RequestModel model, string api_url, string MethodType = "post", string getObjectOnly = null)
        {
            TPResponse _tPResponse = new TPResponse() { ResponseCode = "0" };
            using (HttpClient httpClient = new HttpClient())
            {
                try
                {
                    _log.Info($"{api_url}|REQUEST : {JsonConvert.SerializeObject(model).ToString()}");

                    httpClient.BaseAddress = new Uri(ft_base_url);
                    string tokenNo = GetAuthToken();
                    httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    short timeOut = Convert.ToInt16(GetStatic.ReadWebConfig("transfast_apiTimeOutInSecond", "100"));
                    httpClient.Timeout = new TimeSpan(0, 0, timeOut);
                    httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", tokenNo);
                    HttpResponseMessage resp = new HttpResponseMessage();
                    if (MethodType.ToLower().Equals("get"))
                    {
                        resp = httpClient.GetAsync(api_url).Result;
                    }
                    if (MethodType.ToLower().Equals("put"))
                    {
                        StringContent jbdContent = new StringContent(JsonConvert.SerializeObject(model).ToString(), Encoding.UTF8, "application/json");
                        resp = httpClient.PutAsync(api_url, jbdContent).Result;
                    }
                    if (MethodType.ToLower().Equals("post"))
                    {
                        string jsonData = JsonConvert.SerializeObject(model).ToString();
                        StringContent jbdContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
                        resp = httpClient.PostAsync(api_url, jbdContent).Result;
                    }
                    string result = resp.Content.ReadAsStringAsync().Result;

                    _log.Info($"{api_url}|RESPONSE : {result}");


                    if (resp.IsSuccessStatusCode)
                    {
                        _tPResponse.ResponseCode = "0";
                        _tPResponse.Data = JsonConvert.DeserializeObject<ResponseModelForSucess>(result);
                        if (getObjectOnly != null)
                            _tPResponse = GetOnlyRequiredData(_tPResponse, getObjectOnly);
                        return _tPResponse;
                    }
                    else
                    {

                        _tPResponse.ResponseCode = "1";
                        _tPResponse.Data = JsonConvert.DeserializeObject<ResponseModelForFailed>(result);
                        if (resp.StatusCode.ToString().ToLower() != "notfound")
                        {
                            _tPResponse.Msg = "Status Code: " + resp.StatusCode.ToString().Replace("<br/>", "").Replace(Environment.NewLine, "") + " " + GetResponseMessage(_tPResponse.Data as TFSendTxnFailedResponse);
                        }
                        else
                        {
                            _tPResponse.Msg = "Status Code:" + resp.StatusCode.ToString();
                        }
                        if (getObjectOnly != null)
                            _tPResponse = GetOnlyRequiredData(_tPResponse, getObjectOnly);
                        return _tPResponse;
                    }
                }
                catch (HttpRequestException ex)
                {
                    _tPResponse.ResponseCode = "999";
                    _tPResponse.Msg = ex.Message;
                    _tPResponse.Data = ex.Data;
                }
            };

            return _tPResponse;
        }

        private string GetResponseMessage(TFSendTxnFailedResponse data)
        {
            string msg = "";
            if (data.BusinessErrors != null)
            {
                if (data.BusinessErrors.Count > 0)
                    msg += "Business Error: ";

                foreach (BusinessError item in data.BusinessErrors)
                {
                    msg += item.ErrorCode + " ; " + item.Message + Environment.NewLine;
                }
            }
            if (data.DataValidationErrors != null)
            {
                if (data.BusinessErrors.Count > 0)
                    msg += "Validation Error: ";

                foreach (DataValidationError item in data.DataValidationErrors)
                {
                    msg += item.ErrorCode + " ; " + item.Message + Environment.NewLine;
                }
            }

            if (!string.IsNullOrEmpty(data.Message))
                msg += "Error Msg: " + data.ErrorCode + data.Message;

            return msg;
        }

        #region Model Convert

        private TFSenderRequest ConvertSenderToTFSender(SenderRequest sR)
        {
            return new TFSenderRequest()
            {
                Address = sR.Address,
                AddressOtherLanguage = sR.AddressOtherLanguage,
                CityId = sR.RCityCode,
                CountryIsoCode = sR.CountryIsoCode,
                DateOfBirth = sR.DateOfBirth,
                Email = sR.Email,
                IdExpiryDate = sR.IdExpiryDate,
                IdNumber = sR.IdNumber,
                IsIndividual = sR.IsIndividual,
                //LoyaltyCardNumber = sR.LoyaltyCardNumber,
                Name = sR.Name,
                NameOtherLanguage = sR.NameOtherLanguage,
                NationalityIsoCode = sR.NationalityIsoCode,
                PhoneHome = sR.PhoneHome,
                PhoneMobile = sR.PhoneMobile,
                PhoneWork = sR.PhoneWork,
                SenderId = sR.SenderId,
                StateId = sR.StateId,
                TypeOfId = sR.TypeOfId,
                ZipCode = sR.ZipCode
            };
        }

        private TFSendTxtnRequest ConvertSendTransactionModelToTFSendTxtnRequest(SendTransaction sT)
        {
            return new TFSendTxtnRequest()
            {
                //TfPin = sT.Transaction.JMEControlNo,

                Sender = new TFSenderRequest()
                {
                    SenderId = 0,
                    LoyaltyCardNumber = "",
                    Name = sT.Sender.SFullName,
                    NameOtherLanguage = sT.Sender.SFullName,
                    Address = sT.Sender.SAddress,
                    AddressOtherLanguage = sT.Sender.SAddress,
                    PhoneMobile = sT.Sender.SMobile,
                    PhoneHome = sT.Sender.STel,
                    PhoneWork = "",
                    ZipCode = sT.Sender.SZipCode,
                    CityId = sT.Sender.SCityId,
                    StateId = sT.Sender.SState,
                    CountryIsoCode = sT.Sender.SCountryName,
                    TypeOfId = sT.Sender.SIdType,
                    IdNumber = sT.Sender.SIdNo,
                    IdExpiryDate = sT.Sender.SIdExpiryDate,
                    NationalityIsoCode = sT.Sender.SNativeCountry,
                    DateOfBirth = sT.Sender.SBirthDate,
                    Email = sT.Sender.SEmail,
                    IsIndividual = sT.Sender.IsIndividual
                },

                Receiver = new ReceiverRequest()
                {
                    FirstName = sT.Receiver.RFirstName,
                    FirstNameOtherLanguage = sT.Receiver.RFirstName,
                    SecondName = sT.Receiver.RMiddleName,
                    SecondNameOtherLanguage = sT.Receiver.RMiddleName,
                    LastName = sT.Receiver.RLastName,
                    LastNameOtherLanguage = sT.Receiver.RLastName,
                    SecondLastName = "",
                    SecondLastNameOtherLanguage = "",
                    FullNameOtherLanguage = sT.Receiver.RFullName,
                    FullName = sT.Receiver.RFullName,
                    CompleteAddress = sT.Receiver.RAdd1,
                    CompleteAddressOtherLanguage = sT.Receiver.RAdd1,
                    StateId = sT.Receiver.RStateId,
                    CityId = sT.Receiver.RCity,
                    TownId = sT.Receiver.RLocation,
                    CountryIsoCode = sT.Receiver.RCountry,
                    MobilePhone = sT.Receiver.RMobile,
                    HomePhone = sT.Receiver.RTel,
                    WorkPhone = "",
                    ZipCode = "",
                    DateOfBirth = sT.Receiver.RDob,
                    NationalityIsoCode = sT.Receiver.RNativeCountry,
                    IsIndividual = true,
                    Email = sT.Receiver.REmail,
                    Cpf = "",
                    ReceiverTypeOfId = sT.Receiver.RIdType,
                    ReceiverIdNumber = sT.Receiver.RIdNo,
                    Notes = "",
                    NotesOtherLanguage = ""
                },

                TransactionInfo = new TransactionInfoRequest()
                {
                    PaymentModeId = sT.Transaction.PaymentType,
                    ReceiveCurrencyIsoCode = sT.Transaction.PCurr,
                    BankId = sT.Agent.PBankId,
                    Account = sT.Receiver.RAccountNo,
                    AccountTypeId = "",
                    BankBranchId = sT.Agent.PBankBranchId,
                    PayingBranchId = sT.Agent.PBranchId,
                    PayerId = sT.Receiver.RLocationName,
                    PurposeOfRemittanceId = sT.Transaction.PurposeOfRemittanceName,
                    SourceCurrencyIsoCode = sT.Transaction.CollCurr,
                    Rate = sT.Transaction.Rate,
                    TotalSentAmount = sT.Transaction.TAmt,
                    SentAmount = 0,
                    ServiceFee = sT.Transaction.ServiceCharge,
                    USDServiceFee = sT.Transaction.SettlementDollarRate,
                    ReceiveAmount = sT.Transaction.PAmt,
                    CashAmount = sT.Transaction.CAmt,
                    Payout = 0,
                    FormOfPaymentId = sT.Sender.FormOfPaymentId,
                    ReferenceNumber = sT.Transaction.JMEControlNo,
                    SourceOfFundsID = Convert.ToInt32(sT.Sender.SourceOfFund),
                    FeeProduct = ""
                },

                Compliance = new ComplianceRequest()
                {
                    CountryIssueIsoCode = sT.Receiver.RCountry,
                    ReceiverDateOfBirth = sT.Sender.SBirthDate,
                    ReceiverFullName = sT.Receiver.RFullName,
                    ReceiverRelationship = sT.Receiver.RelWithSenderName,
                    SenderEmployerAddress = sT.Sender.SAddress,
                    SenderEmployerName = sT.Sender.SFullName,
                    SenderEmployerPhone = sT.Sender.SMobile,
                    SenderOccupation = sT.Sender.SOccuptionName,
                    SourceOfFunds = sT.Sender.SourceOfFund,
                    Ssn = sT.Transaction.TpRefNo,
                    StateIssueId = sT.Sender.SState
                },
            };
        }
        private TFAmendTxnRequest ConvertAmendTransactionModelToTFAmendTxtnRequest(AmendTransaction aT)
        {
            return new TFAmendTxnRequest()
            {
                TfPin = aT.TfPinno,

                AmendedSender = new TFAmendSenderRequest()
                {
                    Address = aT.AmendSender.SAddress,
                    PhoneMobile = aT.AmendSender.SMobile,
                    PhoneHome = aT.AmendSender.STel,
                    PhoneWork = "",
                    CityId = aT.AmendSender.SCityId,
                    StateId = aT.AmendSender.SState,
                    CountryIsoCode = aT.AmendSender.SCountryName,
                    ZipCode = aT.AmendSender.SZipCode,
                    IsIndividual = aT.AmendSender.IsIndividual,
                    Email = aT.AmendSender.SEmail,
                    TypeOfId = aT.AmendSender.SIdType,
                    IdNumber = aT.AmendSender.SIdNo,
                    IdExpiryDate = aT.AmendSender.SIdExpiryDate,
                    NationalityIsoCode = aT.AmendSender.SNativeCountry,
                    SenderOccupations = aT.AmendSender.SOccuptionId,
                    DateOfBirth = aT.AmendSender.SBirthDate,
                },

                AmendedReceiver = new ReceiverAmendRequest()
                {
                    CompleteAddress = aT.AmendReceiver.RAdd1,
                    CompleteAddressOtherLanguage = aT.AmendReceiver.RAdd1,
                    MobilePhone = aT.AmendReceiver.RMobile,
                    WorkPhone = "",
                    HomePhone = aT.AmendReceiver.RTel,
                    Email = aT.AmendReceiver.REmail,
                    ReceiverTypeOfId = aT.AmendReceiver.RIdType,
                    ReceiverIdNumber = aT.AmendReceiver.RIdNo,
                    FirstName = aT.AmendReceiver.RFirstName,
                    LastName = aT.AmendReceiver.RLastName,
                    SecondLastName = "",
                    Notes = "",
                    NotesOtherLanguage = ""
                },

                AmendedTransactionInfo = new TransactionInfoAmendRequest()
                {
                    Account = aT.AmendReceiver.RAccountNo,
                    BankBranchId = aT.AmendAgent.PBankBranchId,
                    BankRoutingNumber = aT.AmendAgent.PBankId
                },
            };
        }


        private TFExRateRequest ConvertExchangeRateModelToTFExRateRequest(ExchangeRate sT)
        {
            return new TFExRateRequest()
            {
                FeeProduct = "",
                ReceiveCountryIsoCode = sT.pCountryCode,
                SourceCurrencyIsoCode = sT.SCurrency
            };
        }

        private TFBankRequest ConvetToTFBankRequest(BankRequest bank)
        {
            return new TFBankRequest()
            {
                BankName = bank.BankName,
                CountryIsoCode = bank.CountryCode,
                PageSize = bank.PageSize,
                RoutingNumber = bank.RoutingNumber,
                StartIndex = bank.StartIndex,
                Swiftcode = bank.Swiftcode
            };
        }

        private TFBankBranchRequest ConvetToTFBankBranchRequest(BankRequest bank)
        {
            return new TFBankBranchRequest()
            {
                BankId = bank.BankName,
                CityId = bank.CityId,
                StateId = bank.StateId
            };
        }

        private TFTxnCancelRequest ConvertToTFTxnCancelRequest(CancelTxn txn)
        {
            return new TFTxnCancelRequest()
            {
                TfPin = txn.PartnerPinNo,
                ReasonId = txn.CancelReason
            };
        }

        private TFPayersRequest ConvertToTFPayersRequest(PayerRequest tF)
        {
            return new TFPayersRequest()
            {
                BankId = tF.BankId,
                CityId = tF.CityId,
                CountryIsoCode = tF.CountryIsoCode,
                FeeProduct = tF.FeeProduct,
                PaymentModeId = tF.PaymentModeId,
                ReceiveCurrencyIsoCode = tF.ReceiveCurrencyIsoCode,
                SourceCurrencyIsoCode = tF.SourceCurrencyIsoCode,
            };
        }

        #endregion Model Convert

        private string GetAuthToken()
        {
            string authHeader = "<Authentication> <Id>" + systemId + "</Id> <UserName>" + Encrypt(userName) + "</UserName> <Password>" + Encrypt(password) + "</Password> <BranchId>" + Encrypt(branchId) + "</BranchId> </Authentication>";
            string _authToken = Base64Encode(authHeader);
            return _authToken;
        }

        //private string GetAuthTokenBank()
        //{
        //    string authHeader = "<Authentication> <Id>" + systemId + "</Id> <UserName>" + Encrypt(userNameBank) + "</UserName> <Password>" + Encrypt(passwordBank) + "</Password> <BranchId>" + Encrypt(branchIdBank) + "</BranchId> </Authentication>";
        //    string _authToken = Base64Encode(authHeader);
        //    return _authToken;
        //}

        private static string Base64Encode(string plainText)
        {
            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
            return Convert.ToBase64String(plainTextBytes);
        }

        private string Encrypt(string data)
        {
            using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
            {
                RSA.FromXmlString(publicKey);
                byte[] dataToEncrypt = Encoding.UTF8.GetBytes(data);
                byte[] encryptedByteArray = RSA.Encrypt(dataToEncrypt, false).ToArray();
                return Convert.ToBase64String(encryptedByteArray);
            }
        }

        private TPResponse GetOnlyRequiredData(TPResponse response, string objectName)
        {
            if (response.Data != null)
            {
                PropertyInfo fieldName = response.Data.GetType().GetProperty(objectName);
                object values = fieldName.GetValue(response.Data, null);
                response.Data = values;
            }
            return response;
        }
    }
}