Example #1
0
        public async Task <IActionResult> Post(PaymentReqVM paymentReqVM)
        {
            if (ModelState.IsValid)
            {
                PaymentReqModel paymentReqModel = mapper.Map <PaymentReqVM, PaymentReqModel>(paymentReqVM);

                (PaymentReqRespModel paymentReqRespModel, ModelStateDictionary modelStateDictionary) = await paymentManager.PostAsync(paymentReqModel, ModelState);

                if (!modelStateDictionary.IsValid)
                {
                    return(BadRequest(modelStateDictionary));
                }

                PaymentCreatedRespVM paymentCreatedRespVM = new PaymentCreatedRespVM()
                {
                    Id     = paymentReqRespModel.Id,
                    Status = paymentReqRespModel.Status,
                    Href   = $"/api/v1/Payment/{paymentReqRespModel.Id}"
                };

                return(Created(paymentCreatedRespVM.Href, paymentCreatedRespVM));
            }

            return(BadRequest(ModelState));
        }
        public async Task <string> CreatePaymentRequestAync(PaymentReqModel order)
        {
            var body     = CreatePaymentSignature(order);
            var response = await _apiRequestHelper.PostAsync <dynamic>(_momoOptions.MoMoPaymentEndpoint, requestBody : body);

            if (response.message == "Success")
            {
                return(response.payUrl);
            }

            return(response.ToString());
        }
Example #3
0
        public async Task <(PaymentReqRespModel, ModelStateDictionary)> PostAsync(PaymentReqModel paymentReqModel, ModelStateDictionary modelStateDictionary)
        {
            string paymentReqModelAsString = JsonConvert.SerializeObject(paymentReqModel);

            StringContent stringContent = new StringContent(paymentReqModelAsString, Encoding.UTF8, "application/json");

            (PaymentReqRespModel paymentReqRespModel, string errorMessage) = await httpClientManager.PostAsync <PaymentReqRespModel>(endpointOptions?.Value.Endpoint, stringContent);

            if (!string.IsNullOrEmpty(errorMessage))
            {
                modelStateDictionary.AddModelError("Payment", _Failed_ToPostPayment);
            }

            return(paymentReqRespModel, modelStateDictionary);
        }
        private MoMoPaymentReqModel CreatePaymentSignature(PaymentReqModel order)
        {
            string rawHash = "partnerCode=" +
                             _momoOptions.PartnerCode + "&accessKey=" +
                             _momoOptions.AccessKey + "&requestId=" +
                             order.RequestId + "&amount=" +
                             order.Amount + "&orderId=" +
                             order.OrderId + "&orderInfo=" +
                             order.OrderInfo + "&returnUrl=" +
                             _momoOptions.ReturnUrl + "&notifyUrl=" +
                             _momoOptions.NotifyUrl + "&extraData=" +
                             order.ExtraData;

            //sign signature SHA256
            string SignatureScripted = crypto.signSHA256(rawHash, _momoOptions.SecrectKey);

            var model = _mapper.Map <PaymentReqModel, MoMoPaymentReqModel>(order);

            model.SetMoMoData(_momoOptions, SignatureScripted);

            return(model);
        }
        public async Task <IActionResult> TestPayment(PaymentReqModel model)
        {
            var response = await _moMoPaymentHelper.CreatePaymentRequestAync(model);

            return(Ok(response));
        }