コード例 #1
0
        public async Task <VPATranslateResponse> testvpaEnquiry(VPAEnquiryRequest vrequest)
        {
            VPATranslateResponse vpaTranslateResponse = new VPATranslateResponse();
            Limit l = new Limit();

            l.amount   = 200;
            l.hasLimit = true;

            AssociatedVpas av = new AssociatedVpas();

            av.vpaId = "merchant2@bank3";
            av.limit = l;

            ContactInformation c = new ContactInformation();

            c.email = "*****@*****.**";
            c.phone = "08012345678";

            List <AssociatedVpas> avs = new List <AssociatedVpas>();

            avs.Add(av);

            IndividualInformation i = new IndividualInformation();

            i.bvn        = "12345678900987654123";
            i.firstName  = vrequest.instructedInstitutionCode;
            i.lastName   = "Olu";
            i.middleName = "Musa";

            MerchantInformation m = new MerchantInformation();

            m.companyName = "Jumia";
            m.rcNumber    = "RC1234";
            m.tin         = "";

            VPATranslateResponse v = new VPATranslateResponse();

            v.accountCurrency    = "NGN";
            v.accountName        = "Emeka Olu";
            v.accountNumber      = "0123456789";
            v.associatedVpas     = avs;
            v.contactInformation = c;
            v.error                 = "";
            v.errorDescription      = "";
            v.hasAssociatedVpas     = true;
            v.httpStatusCode        = 200;
            v.individualInformation = i;
            v.merchantInformation   = m;
            v.pspId                 = "bank1";
            v.vpaId                 = vrequest.targetVPA;
            v.vpaType               = "Individual";

            string json = JsonHelper.toJson(v);

            try
            {
                var    content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
                string result  = await content.ReadAsStringAsync();

                //vpaTranslateResponse = (VPATranslateResponse)JsonConvert.DeserializeObject(content);
                vpaTranslateResponse = JsonHelper.fromJson <VPATranslateResponse>(result);
            }
            catch (Exception ec)
            {
                testLogException(new VPAEnquiryException()
                {
                    action    = "Error deserializing translate response: " + json,
                    exception = ec.ToString(),
                    requestId = "Test",
                    logTime   = DateTime.Now
                });
            }
            return(vpaTranslateResponse);
        }
コード例 #2
0
        public async Task <VPAEnquiryResponse> AddressEnquiry([FromBody] VPAEnquiryRequest request)
        {
            //VPAEnquiryResponse response = new VPAEnquiryResponse();
            //VPATranslateResponse vpaTranslateResponse = new VPATranslateResponse();
            //VPAInformation vInfo = new VPAInformation();
            //PersonalInformation pInfo = new PersonalInformation();
            //AccountInformation aInfo = new AccountInformation();
            //MerchantInformation mInfo = new MerchantInformation();
            //List<AssociatedVpas> aVpas = new List<AssociatedVpas>();

            //log request on mongo
            try
            {
                //VPAEnquiryRequest req = new VPAEnquiryRequest()
                //{
                //    channelCode = request.channelCode,
                //    instructedInstitutionCode = request.instructedInstitutionCode,
                //    instructingInstitutionCode = request.instructingInstitutionCode,
                //    requestId = request.requestId,
                //    targetVPA = request.targetVPA,
                //    updatedOn = DateTime.Now
                //};

                _req.channelCode = request.channelCode;
                _req.instructedInstitutionCode  = request.instructedInstitutionCode;
                _req.instructingInstitutionCode = request.instructingInstitutionCode;
                _req.requestId = request.requestId;
                _req.targetVPA = request.targetVPA;
                _req.updatedOn = DateTime.Now;


                VPAEnquiryRequestValidator validator = new VPAEnquiryRequestValidator();
                ValidationResult           results   = validator.Validate(_req);

                bool validationSucceeded           = results.IsValid;
                IList <ValidationFailure> failures = results.Errors;

                if (!validationSucceeded)
                {
                    string desc = string.Empty;
                    foreach (var f in failures)
                    {
                        desc = desc + f.ErrorMessage;
                    }
                    _response.httpStatusCode   = (int)HttpStatusCode.BadRequest;
                    _response.error            = "Bad Request";
                    _response.errorDescription = desc;
                    return(_response);
                }
                //if (!_settings.Value.isTest)
                if (_settings.Value.isTest)
                {
                    string bs = testLogRequest(_req);
                }
                else
                {
                    await _requestRepository.AddVPAEnquiryRequest(_req);
                }
            }
            catch (Exception ex)
            {
                await logException(new VPAEnquiryException()
                {
                    action    = "Error Logging Incoming Request: " + request.targetVPA,
                    exception = ex.ToString(),
                    requestId = request.requestId,
                    logTime   = DateTime.Now
                });
            }

            //check cache for details
            try
            {
                _response = await vpaEnquiry(request.targetVPA);

                if (_response != null && _response.httpStatusCode != 0)
                {
                    return(_response);
                }
            }
            catch (Exception ex)
            {
                await logException(new VPAEnquiryException()
                {
                    action    = "Error Fetching Request From Cache: " + request.targetVPA,
                    exception = ex.ToString(),
                    requestId = request.requestId,
                    logTime   = DateTime.Now
                });
            }

            //assume OK
            _response.httpStatusCode = (int)HttpStatusCode.OK;

            ///vpa translate call
            try
            {
                if (_settings.Value.isTest)
                {
                    //testLogtranslate(request.targetVPA);
                    _vpaTranslateResponse = await testvpaEnquiry(request);
                }
                else
                {
                    _vpaTranslateResponse = await vpaEnquiry(request);
                }

                bool OK = _vpaTranslateResponse.httpStatusCode == (int)HttpStatusCode.OK ||
                          _vpaTranslateResponse.httpStatusCode == (int)HttpStatusCode.Created || _vpaTranslateResponse.httpStatusCode == (int)HttpStatusCode.Accepted;

                if (_vpaTranslateResponse == null || !OK)
                {
                    _response.httpStatusCode   = _vpaTranslateResponse.httpStatusCode;
                    _response.error            = _vpaTranslateResponse.error;
                    _response.errorDescription = _vpaTranslateResponse.errorDescription;
                    return(_response);
                }
                _aVpas = new List <AssociatedVpas>();
                foreach (var avpa in _vpaTranslateResponse.associatedVpas)
                {
                    AssociatedVpas aVpa = new AssociatedVpas()
                    {
                        limit = avpa.limit,
                        vpaId = avpa.vpaId
                    };
                    _aVpas.Add(aVpa);
                }

                _vInfo = new VPAInformation()
                {
                    associatedVpas        = _aVpas,
                    hasAssociatedVPA      = _vpaTranslateResponse.hasAssociatedVpas,
                    virtualPaymentAddress = _vpaTranslateResponse.vpaId
                };
                _response.vpaInformation = _vInfo;
                _pInfo = new PersonalInformation()
                {
                    email             = _vpaTranslateResponse.contactInformation.email,
                    mobilePhoneNumber = _vpaTranslateResponse.contactInformation.phone
                };
                _response.personalInformation = _pInfo;
                _mInfo = new MerchantInformation()
                {
                    companyName = _vpaTranslateResponse.merchantInformation.companyName,
                    rcNumber    = _vpaTranslateResponse.merchantInformation.rcNumber,
                    tin         = _vpaTranslateResponse.merchantInformation.tin
                };
                _response.merchantInformation = _mInfo;
            }
            catch (Exception ex)
            {
                await logException(new VPAEnquiryException()
                {
                    action    = "Error Translating VPA: " + request.targetVPA,
                    exception = ex.ToString(),
                    requestId = request.requestId,
                    logTime   = DateTime.Now
                });
            }

            //account enquiry call
            try
            {
                if (_vpaTranslateResponse != null && !string.IsNullOrEmpty(_vpaTranslateResponse.accountNumber))
                {
                    AccountEnquiryRequest arequest = new AccountEnquiryRequest()
                    {
                        channelCode = request.channelCode,
                        instructedInstitutionCode  = request.instructedInstitutionCode,
                        instructingInstitutionCode = request.instructingInstitutionCode,
                        requestId           = request.requestId,
                        targetAccountNumber = _vpaTranslateResponse.accountNumber
                    };

                    if (_settings.Value.isTest)
                    {
                        _aInfo = await testAccountEnquiry(arequest);
                    }
                    else
                    {
                        _aInfo = await accountEnquiry(arequest);
                    }

                    bool OK = _aInfo.http_status_code == (int)HttpStatusCode.OK ||
                              _aInfo.http_status_code == (int)HttpStatusCode.Created || _aInfo.http_status_code == (int)HttpStatusCode.Accepted;

                    if (_aInfo == null || !OK)
                    {
                        _response.httpStatusCode   = _aInfo.http_status_code;
                        _response.error            = _aInfo.error;
                        _response.errorDescription = _aInfo.error_description;
                        return(_response);
                    }

                    _pInfo = new PersonalInformation()
                    {
                        email             = _aInfo.personalinformation.email,
                        mobilePhoneNumber = _aInfo.personalinformation.mobilePhoneNumber
                    };

                    //AccountInformation ai = new AccountInformation()
                    //{
                    //    accountCategory = aInfo.accountCategory,
                    //    accountCurrency = aInfo.accountCurrency,
                    //    accountEntityName = aInfo.accountEntityName,
                    //    accountFirstName = aInfo.accountFirstName,
                    //    accountLastName = aInfo.accountLastName,
                    //    accountMiddleName = aInfo.accountMiddleName,
                    //    accountNumber = aInfo.accountNumber,
                    //    accountStatus = aInfo.accountStatus,
                    //    accountType = aInfo.accountType,
                    //    authorizationCredentialsAllowed = aInfo.authorizationCredentialsAllowed,
                    //    authorizationCredentialsLength = aInfo.authorizationCredentialsLength,
                    //    authorizationCredentialsType = aInfo.authorizationCredentialsType,
                    //    personalinformation = pInfo,
                    //    verificationNumber = aInfo.verificationNumber,
                    //    verificationNumberType = aInfo.verificationNumberType
                    //};

                    _response.personalInformation = _pInfo;

                    _response.accountInformation = _aInfo;
                }
            }
            catch (Exception ex)
            {
                await logException(new VPAEnquiryException()
                {
                    action    = "Error on Account Enquiry: " + request.targetVPA,
                    exception = ex.ToString(),
                    requestId = request.requestId,
                    logTime   = DateTime.Now
                });
            }

            //add to cache
            try
            {
                string cacheKey   = _vpaTranslateResponse.vpaId;
                string cacheValue = JsonHelper.toJson(_response);
                await _distributedCache.SetStringAsync(cacheKey, cacheValue);
            }
            catch (Exception ex)
            {
                await logException(new VPAEnquiryException()
                {
                    action    = "Error Writing Response to Cache: " + request.targetVPA,
                    exception = ex.ToString(),
                    requestId = request.requestId,
                    logTime   = DateTime.Now
                });
            }

            return(_response);
        }
コード例 #3
0
        public string testLogtranslate(string vpaid)
        {
            BsonValue bs = new BsonValue();

            try
            {
                // Open database (or create if not exits)
                using (var db = new LiteDatabase(@"MyData.db"))
                {
                    // Get requests collection
                    var translates = db.GetCollection <VPATranslateResponse>("translates");

                    Limit l = new Limit();
                    l.amount   = 200;
                    l.hasLimit = true;

                    AssociatedVpas av = new AssociatedVpas();
                    av.vpaId = "merchant2@bank3";
                    av.limit = l;

                    ContactInformation c = new ContactInformation();
                    c.email = "*****@*****.**";
                    c.phone = "08012345678";

                    List <AssociatedVpas> avs = new List <AssociatedVpas>();
                    avs.Add(av);

                    IndividualInformation i = new IndividualInformation();
                    i.bvn        = "12345678900987654123";
                    i.firstName  = "Emeka";
                    i.lastName   = "Olu";
                    i.middleName = "Musa";

                    MerchantInformation m = new MerchantInformation();
                    m.companyName = "Jumia";
                    m.rcNumber    = "RC1234";
                    m.tin         = "";

                    VPATranslateResponse v = new VPATranslateResponse();
                    v.accountCurrency    = "NGN";
                    v.accountName        = "Emeka Olu";
                    v.accountNumber      = "0123456789";
                    v.associatedVpas     = avs;
                    v.contactInformation = c;
                    v.error                 = "";
                    v.errorDescription      = "";
                    v.hasAssociatedVpas     = true;
                    v.httpStatusCode        = 200;
                    v.individualInformation = i;
                    v.merchantInformation   = m;
                    v.pspId                 = "bank1";
                    v.vpaId                 = vpaid;
                    v.vpaType               = "Individual";

                    // Insert new customer document (Id will be auto-incremented)
                    bs = translates.Insert(v);
                }
            }
            catch (Exception ex)
            {
            }
            return(bs.ToString());
        }