public async Task <Response <InitiatePaymentResponse> > StartNewTransaction(InitiateTransactionCommand request)
        {
            var retrieveUser = await _accountService.GetUserById(_authenticatedUser.UserId);

            if (!retrieveUser.Succeeded || retrieveUser.Data is null)
            {
                return new Response <InitiatePaymentResponse> {
                           Succeeded = false, Message = retrieveUser.Message, Errors = retrieveUser.Errors
                }
            }
            ;

            var transaction = _mapper.Map <Transaction>(request);

            transaction.UserId            = _authenticatedUser.UserId;
            transaction.Reference         = Guid.NewGuid().ToString().Replace("-", string.Empty);
            transaction.TransactionStatus = Domain.Enums.TransactionStatus.Initiated;
            await this.AddAsync(transaction);

            var paymentRequest = new InitiatePaymentRequest
            {
                //paystack accepts amount in kobo, please do not change except standards have changed
                Amount       = (transaction.Amount * 100).ToString(),
                Email        = retrieveUser.Data.Email,
                Reference    = transaction.Reference,
                Callback_Url = $"{_paystackSettings.PaymentCallback}"
            };
            var response = await _paymentService.InitializePaystackPayment(paymentRequest);

            if (response.status && response.data != null)
            {
                transaction.SuccessfullyInitiated = true;

                transaction.InitiateMessage = response.message;
                await this.UpdateAsync(transaction);

                return(new Response <InitiatePaymentResponse>
                {
                    Data = response.data,
                    Message = response.message,
                    Succeeded = response.status
                });
            }
            transaction.SuccessfullyInitiated = false;
            transaction.InitiateMessage       = response.message;
            await this.UpdateAsync(transaction);

            return(new Response <InitiatePaymentResponse> {
                Succeeded = response.status, Message = response.message,
            });
        }
    }
Beispiel #2
0
        public ActionResult Initiate()
        {
            var configuration = _configurationLoader.GetConfiguration(_currentMarket.GetCurrentMarket().MarketId);
            var vippsApi      = _vippsServiceApiFactory.Create(configuration);
            var viewModel     = new VippsTestViewModel();

            try
            {
                var orderId = OrderNumberHelper.GenerateOrderNumber();
                var initiatePaymentRequest = new InitiatePaymentRequest
                {
                    CustomerInfo = new CustomerInfo(),
                    MerchantInfo = new MerchantInfo
                    {
                        CallbackPrefix        = EnsureCorrectUrl(configuration.SiteBaseUrl, "vippscallback/"),
                        ConsentRemovalPrefix  = EnsureCorrectUrl(configuration.SiteBaseUrl, "vippscallback/"),
                        FallBack              = EnsureCorrectUrl(configuration.SiteBaseUrl, $"vippstest/fallback?orderId={orderId}"),
                        ShippingDetailsPrefix = EnsureCorrectUrl(configuration.SiteBaseUrl, "vippscallback/"),
                        IsApp = false,
                        MerchantSerialNumber = Convert.ToInt32(configuration.MerchantSerialNumber),
                        PaymentType          = VippsConstants.RegularCheckout
                    },
                    Transaction = new Transaction
                    {
                        Amount          = 20000,
                        OrderId         = orderId,
                        TimeStamp       = DateTime.Now,
                        TransactionText = "test"
                    }
                };

                var result = vippsApi.Initiate(initiatePaymentRequest).Result;

                return(Redirect(result.Url));
            }

            catch (Exception ex)
            {
                viewModel.Message = $"Initiate payment failed. Exception: {ex.Message} {ex.InnerException} {ex.StackTrace}";
                return(View("Index", viewModel));
            }
        }
        public async Task <PaystackBaseResponse <InitiatePaymentResponse> > InitializePaystackPayment(InitiatePaymentRequest request)
        {
            var token   = _externalAuthService.GetPaystackToken();
            var headers = new Dictionary <string, string> {
                { "Authorization", $"Bearer {token}" }
            };
            var response = await _httpClient.PostAsJsonAsync <PaystackBaseResponse <InitiatePaymentResponse> >
                               (request, $"{_paystackSettings.BaseUrl}{_paystackSettings.InitializeTransactionUrl}", headers);

            return(response);
        }