public async Task SavePaymentResponseAsync(CreatePaymentResponse createPaymentResponse) { if (createPaymentResponse == null) { createPaymentResponse = new CreatePaymentResponse(); } var jsonSerializedCreatePaymentResponse = JsonConvert.SerializeObject(createPaymentResponse); var request = new HttpRequestMessage { Method = HttpMethod.Put, RequestUri = new Uri($"http://vbase.{this._environmentVariableProvider.Region}.vtex.io/{this._httpContextAccessor.HttpContext.Request.Headers[HEADER_VTEX_ACCOUNT]}/master/buckets/{this._applicationName}/{RESPONSE_BUCKET}/files/{createPaymentResponse.paymentId}"), Content = new StringContent(jsonSerializedCreatePaymentResponse, Encoding.UTF8, APPLICATION_JSON) }; string authToken = this._httpContextAccessor.HttpContext.Request.Headers[HEADER_VTEX_CREDENTIAL]; if (authToken != null) { request.Headers.Add(AUTHORIZATION_HEADER_NAME, authToken); } var response = await _httpClient.SendAsync(request); response.EnsureSuccessStatusCode(); }
public void OnPost() { string nonce = Request.Form["nonce"]; IPaymentsApi PaymentsApi = client.PaymentsApi; // Every payment you process with the SDK must have a unique idempotency key. // If you're unsure whether a particular payment succeeded, you can reattempt // it with the same idempotency key without worrying about double charging // the buyer. string uuid = NewIdempotencyKey(); // Monetary amounts are specified in the smallest unit of the applicable currency. // This amount is in cents. It's also hard-coded for $1.00, // which isn't very useful. Money amount = new Money.Builder() .Amount(500L) .Currency("USD") .Build(); // To learn more about splitting payments with additional recipients, // see the Payments API documentation on our [developer site] // (https://developer.squareup.com/docs/payments-api/overview). CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest.Builder(nonce, uuid, amount) .Note("From Square Sample Csharp App") .Build(); try { CreatePaymentResponse response = PaymentsApi.CreatePayment(createPaymentRequest); this.ResultMessage = "Payment complete! " + response.Payment.Note; } catch (ApiException e) { this.ResultMessage = e.Message; } }
public void CreatePaymentTest_FailFor_DateNotSupplied() { decimal initialBalance = InMemoryData.CurrentBalance; CreatePaymentResponse response = CreatePaymentResponse(10m, DateTime.MinValue); AssertForCreatePaymentTests(response, initialBalance, "Amount must be supplied and must be positive number and date must be supplied"); }
public async Task <CreatePaymentResponse> Send() { CreatePaymentResponse response = await SendRequestToServer <CreatePaymentResponse>(); this.customerToken = response.customerToken; return(response); }
static async Task <string> AddPayment(decimal amount, DateTime dateTime) { Console.WriteLine(); Console.WriteLine("******add payment test***********"); Console.WriteLine(); Uri u = new Uri(baseUrl + "createpayment"); var response = string.Empty; using (var client = new HttpClient()) { CreatePaymentRequest payload = new CreatePaymentRequest(); payload.Amount = amount; payload.PaymentDate = dateTime; HttpResponseMessage res = await client.PostAsJsonAsync(u, payload); if (res.IsSuccessStatusCode) { CreatePaymentResponse reply = await res.Content.ReadAsAsync <CreatePaymentResponse>(); newlyAddedPayments.Add(new KeyValuePair <Guid, string>(reply.Payment.PaymentId, reply.Payment.Status)); return(JsonConvert.SerializeObject(reply)); } } return(response); }
public void CreatePaymentTest_Validate_Approve_Status_Balance_Check() { decimal initialBalance = InMemoryData.CurrentBalance; CreatePaymentRequest request = new CreatePaymentRequest { Amount = 10, PaymentDate = DateTime.Now }; PaymentValidatorService validatorService = new PaymentValidatorService(); PaymentService paymentService = new PaymentService(validatorService); CreatePaymentResponse response = paymentService.CreatePayment(request); if (response.IsValid && response.Payment != null && response.Payment.RunningBalance == initialBalance && response.ErrorMessages.Count == 0 && response.Payment.Status == "Pending") { ApprovePaymentRequest approvePaymentRequest = new ApprovePaymentRequest(); approvePaymentRequest.PaymentId = response.Payment.PaymentId; ApprovePaymentResponse approvePaymentResponse = paymentService.ApprovePayment(approvePaymentRequest); if (approvePaymentResponse.IsValid) { Assert.IsTrue(approvePaymentResponse.Payment.Status == "Processed"); Assert.IsTrue(approvePaymentResponse.Payment.RunningBalance == (initialBalance - request.Amount)); Assert.IsTrue(approvePaymentResponse.Payment.Amount == request.Amount); } } else { string msg = string.Empty; string delimiter = Environment.NewLine; response.ErrorMessages.ForEach(x => msg += x + delimiter); Assert.Fail(msg); } }
public async Task <CreatePaymentResponse> GetPaymentResponseAsync(string paymentId) { // Console.WriteLine($"GetPaymentRequestAsync called with {this._httpContextAccessor.HttpContext.Request.Headers[HEADER_VTEX_ACCOUNT]},master,{this._environmentVariableProvider.ApplicationName},{this._environmentVariableProvider.ApplicationVendor},{this._environmentVariableProvider.Region}"); var request = new HttpRequestMessage { Method = HttpMethod.Get, RequestUri = new Uri($"http://vbase.{this._environmentVariableProvider.Region}.vtex.io/{this._httpContextAccessor.HttpContext.Request.Headers[HEADER_VTEX_ACCOUNT]}/master/buckets/{this._applicationName}/{RESPONSE_BUCKET}/files/{paymentId}"), }; string authToken = this._httpContextAccessor.HttpContext.Request.Headers[HEADER_VTEX_CREDENTIAL]; if (authToken != null) { request.Headers.Add(AUTHORIZATION_HEADER_NAME, authToken); } var response = await _httpClient.SendAsync(request); string responseContent = await response.Content.ReadAsStringAsync(); if (response.StatusCode == HttpStatusCode.NotFound) { return(null); } // A helper method is in order for this as it does not return the stack trace etc. response.EnsureSuccessStatusCode(); CreatePaymentResponse paymentResponse = JsonConvert.DeserializeObject <CreatePaymentResponse>(responseContent); return(paymentResponse); }
public async Task PostCallbackResponse(string callbackUrl, CreatePaymentResponse createPaymentResponse) { HttpResponseMessage response = new HttpResponseMessage(); // Internal vtex posts must be to http with use https header callbackUrl = callbackUrl.Replace("https", "http"); try { var jsonSerializedPaymentResponse = JsonConvert.SerializeObject(createPaymentResponse); var request = new HttpRequestMessage { Method = HttpMethod.Post, RequestUri = new Uri(callbackUrl), Content = new StringContent(jsonSerializedPaymentResponse, Encoding.UTF8, APPLICATION_JSON) }; string authToken = this._httpContextAccessor.HttpContext.Request.Headers[HEADER_VTEX_CREDENTIAL]; if (authToken != null) { request.Headers.Add(AUTHORIZATION_HEADER_NAME, authToken); } response = await _httpClient.SendAsync(request); } catch (Exception ex) { _context.Vtex.Logger.Error("PostCallBackResponse", null, $"PostCallbackResponse {callbackUrl} Error: {ex.Message} InnerException: {ex.InnerException} StackTrace: {ex.StackTrace}", ex); } response.EnsureSuccessStatusCode(); }
public async Task Test() { CreatePaymentRequest body = new CreatePaymentRequest(); Order order = new Order(); AmountOfMoney amountOfMoney = new AmountOfMoney(); amountOfMoney.CurrencyCode = ("EUR"); amountOfMoney.Amount = (100L); order.AmountOfMoney = (amountOfMoney); Customer customer = new Customer(); customer.Locale = ("en"); Address billingAddress = new Address(); billingAddress.CountryCode = ("NL"); customer.BillingAddress = (billingAddress); order.Customer = (customer); body.Order = (order); RedirectionData redirectionData = new RedirectionData(); redirectionData.ReturnUrl = ("http://example.com/"); RedirectPaymentMethodSpecificInput paymentMethodSpecificInput = new RedirectPaymentMethodSpecificInput(); paymentMethodSpecificInput.RedirectionData = redirectionData; paymentMethodSpecificInput.PaymentProductId = (809); RedirectPaymentProduct809SpecificInput paymentProductSpecificInput = new RedirectPaymentProduct809SpecificInput(); paymentProductSpecificInput.IssuerId = ("INGBNL2A"); paymentMethodSpecificInput.PaymentProduct809SpecificInput = (paymentProductSpecificInput); body.RedirectPaymentMethodSpecificInput = (paymentMethodSpecificInput); string idempotenceKey = Guid.NewGuid().ToString(); CallContext context = new CallContext().WithIdempotenceKey(idempotenceKey); using (Client client = GetClient()) { CreatePaymentResponse response = await client.Merchant(GetMerchantId()).Payments().Create(body, context); string paymentId = response.Payment.Id; Assert.AreEqual(idempotenceKey, context.IdempotenceKey); Assert.Null(context.IdempotenceRequestTimestamp); response = await client.Merchant(GetMerchantId()).Payments().Create(body, context); Assert.AreEqual(paymentId, response.Payment.Id); Assert.AreEqual(idempotenceKey, context.IdempotenceKey); Assert.NotNull(context.IdempotenceRequestTimestamp); } }
public static void SetPaymentResponse(this CreatePaymentResponse res, Payment payment) { res.PaymentId = payment.Id; res.PaymentCode = payment.PaymentCode; res.CreateBy = payment.CreatedBy; res.CreateDate = payment.CreatedDate; res.UpdateBy = payment.UpdatedBy; res.UpdateDate = payment.UpdatedDate; res.CustomerIDMPartyID = payment.CustomerIdmPartyId; res.CustomerCode = null; res.CustomerName = payment.CustomerName; res.CustomerAddress = payment.CustomerAddress; res.CustomerAccountNumber = payment.CustomerRefundAccountNo; res.CustomerAccountName = payment.CustomerRefundAccountName; res.CustomerAccountBankId = payment.CustomerRefundBankId; res.CustomerMobilePhoneNumber = payment.CustomerMobilePhoneNo; res.Remark = payment.Remark; res.Ref1 = payment.Ref1; res.Ref2 = payment.Ref2; res.Ref3 = payment.Ref3; res.PaymentStatus = payment.Status; res.RemainingAmount = payment.RemainingAmount(); res.GrandTotal = payment.GrandTotal(); res.TotalVatAmount = payment.TotalVat(); res.TotalWithholdingTaxAmount = payment.TotalWithholdingTax(); res.TotalBeforeAdjustment = payment.TotalNoDiscount(); res.TotalAdjustment = payment.TotalDiscount(); res.PaymentItems = payment.PaymentItems.CreatePaymentResponseItem(); }
public async Task <IActionResult> ProcessPaymentAsync(string nonce) { try { Square.Environment environment = appSettings.Environment == "sandbox" ? Square.Environment.Sandbox : Square.Environment.Production; // Build base client SquareClient client = new SquareClient.Builder() .Environment(environment) .AccessToken(this.appSettings.AccessToken) .Build(); IPaymentsApi PaymentsApi = client.PaymentsApi; CreatePaymentRequest request_body = new CreatePaymentRequest(nonce, this.NewIdempotencyKey(), new Money(100, "USD")); CreatePaymentResponse responce = await PaymentsApi.CreatePaymentAsync(request_body); if (responce?.Payment?.Status == "COMPLETED") { //this.UpdateCart(new CartModel()); return(this.Ok()); } else { return(this.BadRequest($"STATUS: {responce?.Payment?.Status}")); } } catch (Exception ex) { return(this.BadRequest($"PaymentError: { ex.Message }")); } }
public async Task TestIdempotenceFirstRequest() { string body = idempotenceSucessJson; string idempotenceKey = Guid.NewGuid().ToString(); IDictionary <string, string> responseHeaders = new Dictionary <string, string> { { "Location", "http://localhost/v2/20000/payments/000002000020142549460000100001" } }; IDictionary <string, string> requestHeaders = new Dictionary <string, string>(); CallContext context = new CallContext().WithIdempotenceKey(idempotenceKey); using (MockServer host = new MockServer(Port, "/v2/20000/payments", (request, response, arg3) => { RecordRequest((HttpStatusCode)201, request, requestHeaders, response, responseHeaders); return(body); })) using (IClient client = CreateClient()) { CreatePaymentRequest request = CreateRequest(); CreatePaymentResponse response = await client.WithNewMerchant("20000").Payments.CreatePayment(request, context) .ConfigureAwait(false); Assert.NotNull(response); Assert.NotNull(response.Payment); Assert.NotNull(response.Payment.Id); } Assert.AreEqual(idempotenceKey, requestHeaders[("X-GCS-Idempotence-Key")]); Assert.AreEqual(idempotenceKey, context.IdempotenceKey); Assert.Null(context.IdempotenceRequestTimestamp); }
public void CreatePaymentTest_NotEnoughBalance() { decimal initialBalance = InMemoryData.CurrentBalance; CreatePaymentResponse response = CreatePaymentResponse(100001m, DateTime.Now); AssertForCreatePaymentTests(response, initialBalance, "Not Enough Balance"); }
public async Task TestIdempotenceSecondRequest() { string body = idempotenceSucessJson; string idempotenceKey = Guid.NewGuid().ToString(); double idempotenceRequestTimestamp = (DateTime.UtcNow - Jan1st1970).TotalMilliseconds; IDictionary <string, string> responseHeaders = new Dictionary <string, string>(1); responseHeaders.Add("Location", "http://localhost/v1/20000/payments/000002000020142549460000100001"); responseHeaders.Add("X-GCS-Idempotence-Request-Timestamp", idempotenceRequestTimestamp.ToString()); IDictionary <string, string> requestHeaders = new Dictionary <string, string>(); CallContext context = new CallContext().WithIdempotenceKey(idempotenceKey); using (MockServer host = new MockServer(Port, "/v1/20000/payments", (request, response, arg3) => { RecordRequest((HttpStatusCode)201, request, requestHeaders, response, responseHeaders); return(body); })) using (Client client = CreateClient()) { CreatePaymentRequest request = CreateRequest(); CreatePaymentResponse response = await client.Merchant("20000").Payments().Create(request, context); Assert.NotNull(response); Assert.NotNull(response.Payment); Assert.NotNull(response.Payment.Id); } Assert.AreEqual(idempotenceKey, requestHeaders[("X-GCS-Idempotence-Key")]); Assert.AreEqual(idempotenceKey, context.IdempotenceKey); Assert.Null(context.IdempotenceRequestTimestamp); }
private static void ValidateResponse(CreatePaymentResponse response) { if (response.Status != "Ok") { throw new ValidationException("Status of the BitBayPay API call has failed"); } }
private void AssertForCreatePaymentTests(CreatePaymentResponse response, decimal initialBalance, string errMsg) { Assert.IsFalse(response.IsValid); Assert.IsNull(response.Payment); Assert.IsTrue(response.ErrorMessages.Count > 0); Assert.IsTrue(InMemoryData.CurrentBalance == initialBalance); Assert.IsTrue(response.ErrorMessages[0] == errMsg); }
public async Task Test() { CreatePaymentRequest body = new CreatePaymentRequest { Order = new Order { AmountOfMoney = new AmountOfMoney { CurrencyCode = "EUR", Amount = 100L }, Customer = new Customer { Locale = "en", BillingAddress = new Address { CountryCode = "NL" } } }, CardPaymentMethodSpecificInput = new CardPaymentMethodSpecificInput { PaymentProductId = 1, IsRecurring = false, SkipAuthentication = true, Card = new Card { CardholderName = "Wile E. Coyote", CardNumber = "4330264936344675", ExpiryDate = "1230", Cvv = "123" } } }; string idempotenceKey = Guid.NewGuid().ToString(); CallContext context = new CallContext().WithIdempotenceKey(idempotenceKey); using (Client client = GetClient()) { CreatePaymentResponse response = await client.WithNewMerchant(GetMerchantId()).Payments.CreatePayment(body, context) .ConfigureAwait(false); string paymentId = response.Payment.Id; Assert.AreEqual(idempotenceKey, context.IdempotenceKey); Assert.Null(context.IdempotenceRequestTimestamp); response = await client.WithNewMerchant(GetMerchantId()).Payments.CreatePayment(body, context) .ConfigureAwait(false); Assert.AreEqual(paymentId, response.Payment.Id); Assert.AreEqual(idempotenceKey, context.IdempotenceKey); Assert.NotNull(context.IdempotenceRequestTimestamp); } }
private CreatePaymentResponse CreatePaymentResponse(decimal amount, DateTime paymentDate) { CreatePaymentRequest request = new CreatePaymentRequest { Amount = amount, PaymentDate = paymentDate }; PaymentValidatorService validatorService = new PaymentValidatorService(); PaymentService paymentService = new PaymentService(validatorService); CreatePaymentResponse response = paymentService.CreatePayment(request); return(response); }
/// <summary> /// https://{{providerApiEndpoint}}/payments /// Creates a new payment and/or initiates the payment flow. /// </summary> /// <param name="createPaymentRequest"></param> /// <returns></returns> public async Task <IActionResult> CreatePayment() { string publicKey = HttpContext.Request.Headers[AffirmConstants.PublicKeyHeader]; var bodyAsText = await new System.IO.StreamReader(HttpContext.Request.Body).ReadToEndAsync(); CreatePaymentRequest createPaymentRequest = JsonConvert.DeserializeObject <CreatePaymentRequest>(bodyAsText); CreatePaymentResponse paymentResponse = await this._affirmPaymentService.CreatePayment(createPaymentRequest, publicKey); Response.Headers.Add("Cache-Control", "private"); return(Json(paymentResponse)); }
public IActionResult Paid() { Square.Environment environment = this.appSettings.Environment == "sandbox" ? Square.Environment.Sandbox : Square.Environment.Production; // Build base client SquareClient client = new SquareClient.Builder() .Environment(environment) .AccessToken(this.appSettings.AccessToken) .Build(); string nonce = Request.Form["nonce"]; IPaymentsApi PaymentsApi = client.PaymentsApi; // Every payment you process with the SDK must have a unique idempotency key. // If you're unsure whether a particular payment succeeded, you can reattempt // it with the same idempotency key without worrying about double charging // the buyer. string uuid = this.NewIdempotencyKey(); // Monetary amounts are specified in the smallest unit of the applicable currency. // This amount is in cents. It's also hard-coded for $1.00, // which isn't very useful. Money amount = new Money.Builder() .Amount(500L) .Currency("USD") .Build(); // To learn more about splitting payments with additional recipients, // see the Payments API documentation on our [developer site] // (https://developer.squareup.com/docs/payments-api/overview). CreatePaymentRequest createPaymentRequest = new CreatePaymentRequest.Builder(nonce, uuid, amount) .Note("From Square Visit Cart App") .Build(); try { CreatePaymentResponse response = PaymentsApi.CreatePayment(createPaymentRequest); PaymentResultModel model = new PaymentResultModel { ResultMessage = "Payment complete! " + response.Payment.Note }; return(View(model)); } catch (ApiException ex) { return(View("PaymentError", new ErrorViewModel { Message = ex.Message })); } }
public async Task <CreatePaymentResponse> CreatePayment(CreatePaymentRequest request, Merchant merchant) { try { if (merchant == null) { return(null); } _log.LogInformation($"Requesting bank for merchant {merchant.Id} : {request.Amount:C2}"); var bankResponse = await _bankGateway.SubmitPayment(PaymentMapper.MapGatewayRequest(request)); _log.LogInformation($"Bank response for merchant {merchant.Id} : {bankResponse.Status} "); var payment = await _paymentRepository.Add(PaymentMapper.MapPayment(bankResponse, merchant, _encryptionProvier)); var isPaymentSuccessfull = bankResponse.Status == BankGatewayPaymentStatus.Successfull; var result = new CreatePaymentResponse { IsSuccessfull = isPaymentSuccessfull }; if (isPaymentSuccessfull) { result.PaymentId = payment.Id; } else { result.ErrorMessage = "Unable to process payment with Bank"; } _log.LogInformation($"Created Payment for merchant {merchant.Id} : {result.PaymentId} "); return(result); } catch (Exception ex) { _log.LogError("Unabl to process paument", ex); return(new CreatePaymentResponse { IsSuccessfull = false, ErrorMessage = "An unexpected error occured, please try again later or contact support" }); } }
public async Task SendPaymentResponse(PaymentEntity paymentEntity, string corrId) { var msg = new CreatePaymentResponse { CorrelationId = corrId, OrderId = paymentEntity.OrderId, PaymentInformation = new PaymentInformation { PaymentAmount = paymentEntity.AmountPayable, PaymentId = paymentEntity.PaymentId, PaymentStatus = paymentEntity.PaymentStatus.GetDisplayName() } }; await SendMessage(msg, corrId); }
public static DenhacResponse CreatePaymentService(string member_id, double amount, string payment_type_id, string notes) { var resultStr = CallGet(hostName + "/createpayment?member_id=" + member_id + "&amount=" + amount + "&payment_type_id=" + payment_type_id + "¬es=" + notes); CreatePaymentResponse responseObj = JsonConvert.DeserializeObject <CreatePaymentResponse>(resultStr); if (responseObj.created != null && responseObj.created.Equals("True")) { responseObj.transactionStatus = true; } else { responseObj.transactionStatus = false; } return(responseObj); }
public CreatePaymentResponse CreatePayment(CreatePaymentRequest req) { var res = new CreatePaymentResponse(); try { using (var idmClient = new IDMServiceClient()) using (var container = new TransactionModelContainer()) { ValidateCreatePaymentRequest(idmClient, req); var payment = new Payment( req.CreateBy, req.CustomerIDMPartyID, req.CustomerName, req.CustomerAddress, req.PaymentItems.CreatePaymentItems() ); var grandTotal = payment.GrandTotal(); var credits = container.CustomerCredits.Where(x => x.CustomerIdmPartyId == req.CustomerIDMPartyID && x.IsUsedOrRefund == false).ToList(); var credit = credits.GetCustomerCredit(grandTotal); foreach (var c in credit) { payment.AddPaymentItem(PaymentItem.CreateCustomerCredit(c.Id, c.Amount)); } CustomerCredit.UpdateCustomerCredit(credit); container.Payments.AddObject(payment); container.SaveChanges(); res.SetPaymentResponse(payment); res.Succeed(); } } catch (Exception x) { res.Fail(x); CreateLog(req, x); } return(res); }
public async Task <IActionResult> CreatePaymentRequest([FromBody] CreatePaymentRequestModel request) { if (string.IsNullOrWhiteSpace(request.SettlementAsset)) { return(BadRequest(PaymentErrorResponseModel.Create(PaymentErrorType.InvalidSettlementAsset))); } if (string.IsNullOrWhiteSpace(request.PaymentAsset)) { return(BadRequest(PaymentErrorResponseModel.Create(PaymentErrorType.InvalidPaymentAsset))); } try { var domainRequest = Mapper.Map <CreatePaymentRequest>(request, opt => opt.Items["MerchantId"] = _headersHelper.MerchantId); CreatePaymentResponse createResponse = await _paymentRequestService.CreatePaymentRequestAsync(domainRequest); PaymentRequestDetailsModel paymentRequestDetails = await _paymentRequestService.GetPaymentRequestDetailsAsync(_headersHelper.MerchantId, createResponse.Id); return(Ok(paymentRequestDetails.ToStatusApiModel())); } catch (InvalidSettlementAssetException ex) { _log.Error(ex, null, $"request: {request.ToJson()}"); return(BadRequest(PaymentErrorResponseModel.Create(PaymentErrorType.InvalidSettlementAsset))); } catch (InvalidPaymentAssetException ex) { _log.Error(ex, null, $"request: {request.ToJson()}"); return(BadRequest(PaymentErrorResponseModel.Create(PaymentErrorType.InvalidPaymentAsset))); } catch (Exception ex) { _log.Error(ex, null, $"request: {request.ToJson()}"); throw; } }
public async Task TestCreateSuccess() { var connectionMock = new Mock <IConnection>(); connectionMock.Setup(arg => arg.Post(Moq.It.IsAny <Uri>(), Moq.It.IsAny <IEnumerable <IRequestHeader> >(), Moq.It.IsAny <string>())).ReturnsAsync(new Response((HttpStatusCode)201, pendingApprovalJson, null)); Uri apiEndpoint = new Uri("http://localhost"); var session = new Session(apiEndpoint, connectionMock.Object, new DefaultAuthenticator(AuthorizationType.V1HMAC, "test", "test"), new MetaDataProvider("Ingenico")); Client client = Factory.CreateClient(session); CreatePaymentRequest body = CreateRequest(); CreatePaymentResponse response = await client.Merchant("merchantId").Payments().Create(body); Assert.AreEqual("000002000020142549460000100001", response.Payment.Id); Assert.AreEqual("PENDING_APPROVAL", response.Payment.Status); }
public async Task <string> PostCallbackResponse(string callbackUrl, CreatePaymentResponse createPaymentResponse) { string message = string.Empty; // Empty message signifies success HttpResponseMessage response = new HttpResponseMessage(); try { // Internal vtex posts must be to http with use https header callbackUrl = callbackUrl.Replace("https", "http"); var jsonSerializedPaymentResponse = JsonConvert.SerializeObject(createPaymentResponse); var request = new HttpRequestMessage { Method = HttpMethod.Post, RequestUri = new Uri(callbackUrl), Content = new StringContent(jsonSerializedPaymentResponse, Encoding.UTF8, APPLICATION_JSON) }; request.Headers.Add(FlowFinanceConstants.USE_HTTPS_HEADER_NAME, "true"); string authToken = this._httpContextAccessor.HttpContext.Request.Headers[HEADER_VTEX_CREDENTIAL]; if (authToken != null) { request.Headers.Add(AUTHORIZATION_HEADER_NAME, authToken); request.Headers.Add(VTEX_ID_HEADER_NAME, authToken); } var client = _clientFactory.CreateClient(); response = await client.SendAsync(request); } catch (Exception ex) { Console.WriteLine($"PostCallbackResponse to '{callbackUrl}' Error: {ex.Message} InnerException: {ex.InnerException} StackTrace: {ex.StackTrace}"); message = $"PostCallbackResponse '{createPaymentResponse.status}' to '{callbackUrl}' Error: {ex.Message} InnerException: {ex.InnerException} StackTrace: {ex.StackTrace}"; } //response.EnsureSuccessStatusCode(); if (!response.IsSuccessStatusCode) { Console.WriteLine($"PostCallbackResponse to '{callbackUrl}' status [{response.StatusCode}]"); message = $"PostCallbackResponse '{createPaymentResponse.status}' to '{callbackUrl}' status [{response.StatusCode}]"; } return(message); }
/// <summary> /// Executes the WorkFlow. /// </summary> /// <param name="crmWorkflowContext">The <see cref="WorkFlowActivityBase.LocalWorkflowContext"/> which contains the /// <param name="executionContext" > <see cref="CodeActivityContext"/> /// </param> /// <remarks> /// For improved performance, Microsoft Dynamics 365 caches WorkFlow instances. /// The WorkFlow's Execute method should be written to be stateless as the constructor /// is not called for every invocation of the WorkFlow. Also, multiple system threads /// could execute the WorkFlow at the same time. All per invocation state information /// is stored in the context. This means that you should not use global variables in WorkFlows. /// </remarks> public override void ExecuteCRMWorkFlowActivity(CodeActivityContext executionContext, LocalWorkflowContext crmWorkflowContext) { var tracingService = executionContext.GetExtension <ITracingService>(); tracingService.Trace("CreatePayment starting..."); try { // 1. Validation ValidateNotNull(crmWorkflowContext); // 2. Prepare API Request tracingService.Trace("Calling PrepareCardPaymentRequest..."); CreatePaymentRequest apiRequest = this.PrepareCardPaymentRequest(executionContext); // 2. Retrieve Configuration tracingService.Trace("Calling RetrieveCardPaymentServiceConfiguration..."); RestServiceConfiguration cardServiceConfiguration = this.RetrieveCardPaymentServiceConfiguration(executionContext, ConfigurationPrefix.Get(executionContext)); // 3. Set-up the Api Service tracingService.Trace("Instantiating CardPaymentService..."); CardPaymentService cardPaymentService = new CardPaymentService(cardServiceConfiguration); // 4. Call the API tracingService.Trace("Calling GovPay CreatePayment with amount='{0}', description='{1}', reference='{2}', returnUrl='{3}'", apiRequest.amount, apiRequest.description, apiRequest.reference, apiRequest.return_url); CreatePaymentResponse apiResponse = cardPaymentService.CreatePayment(apiRequest); // TODO Log request and Response // 5. Return the response if (apiResponse != null && apiResponse.error_message != null) { tracingService.Trace("Error message: {0}", apiResponse.error_message); } tracingService.Trace("Calling PrepareOutputParameters..."); this.PrepareOutputParameters(executionContext, apiResponse, tracingService); } catch (Exception ex) { // Todo: Log the Error tracingService.Trace("Exception: " + ex); throw ex; } }
public CreatePaymentResponse CreatePayment(string baseUri, double amount) { string guid = Convert.ToString((new Random()).Next(100000)); var createdPayment = CreatePaymentInternal(_apiContext, baseUri + "guid=" + guid, amount); List<Links> links = createdPayment.links; string paypalRedirectUrl = null; var redirectLink = links.FirstOrDefault(x => x.rel.ToLower().Trim().Equals("approval_url")); if (redirectLink==null) throw new Exception("Redirect link is null"); paypalRedirectUrl = redirectLink.href; var response = new CreatePaymentResponse { Guid = guid, PaymentId = createdPayment.id, RedirectUrl = paypalRedirectUrl }; return response; }
public void CreatePaymentTest_Validate_status() { CreatePaymentResponse response = CreatePaymentResponse(10m, DateTime.Now); if (response != null && response.IsValid && response.Payment != null && response.Payment.RunningBalance == InMemoryData.CurrentBalance && response.ErrorMessages.Count == 0 && response.Payment.Status == "Pending") { Assert.IsTrue(response.IsValid); } else { string msg = string.Empty; string delimiter = Environment.NewLine; response?.ErrorMessages.ForEach(x => msg += x + delimiter); Assert.Fail(msg); } }
/// <summary> /// Read the charge information, current charge status, and checkout data /// </summary> /// <param name="paymentIdentifier">Payment GUID</param> /// <param name="token"></param> /// <returns></returns> public async Task <IActionResult> ReadCharge(string paymentIdentifier, string sandboxMode) { string privateKey = HttpContext.Request.Headers[AffirmConstants.PrivateKeyHeader]; string publicKey = HttpContext.Request.Headers[AffirmConstants.PublicKeyHeader]; if (string.IsNullOrWhiteSpace(privateKey) || string.IsNullOrWhiteSpace(publicKey)) { return(BadRequest()); } else { CreatePaymentResponse paymentResponse = await this._affirmPaymentService.ReadCharge(paymentIdentifier, publicKey, privateKey, bool.Parse(sandboxMode)); _context.Vtex.Logger.Info("ReadCharge", null, $"{paymentIdentifier} {JsonConvert.SerializeObject(paymentResponse)}"); Response.Headers.Add("Cache-Control", "private"); return(Json(paymentResponse)); } }