Example #1
0
        public CapturePaymentResponse CapturePayment(long paymentId, double amount)
        {
            int amountCapture = Convert.ToInt32(amount * 100);
            CapturePaymentResponse response = null;
            RestResponse           result   = this.restClient.Put(String.Format("payments/{0}", paymentId.ToString()), "{\"amount\": " + amountCapture.ToString() + " }");

            if (result.StatusCode != STATUS_NOCONTENT && result.StatusCode != STATUS_OK)
            {
                if (isErrorResponse(result.StatusCode))
                {
                    throw new ResponseException(result.StatusCode.ToString(), JsonConvert.DeserializeObject <ErrorResponse>(result.Response));
                }
                else
                {
                    throw new ResponseException(result.StatusCode + " - " + result.Response);
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(result.Response))
                {
                    response = JsonConvert.DeserializeObject <CapturePaymentResponse>(result.Response);
                }
            }

            return(response);
        }
        public CapturePaymentResponse Capture(CapturePaymentRequest capturePaymentRequest)
        {
            var result = new CapturePaymentResponse();

            result.AddError("Capture method not supported");
            return(result);
        }
Example #3
0
        /// <summary>
        /// https://{{providerApiEndpoint}}/payments/{{paymentId}}/settlements
        /// </summary>
        /// <param name="paymentId">VTEX payment ID from this payment</param>
        /// <param name="capturePaymentRequest"></param>
        /// <returns></returns>
        public async Task <IActionResult> CapturePayment(string paymentId)
        {
            string privateKey = HttpContext.Request.Headers[AffirmConstants.PrivateKeyHeader];
            string publicKey  = HttpContext.Request.Headers[AffirmConstants.PublicKeyHeader];

            var bodyAsText = await new System.IO.StreamReader(HttpContext.Request.Body).ReadToEndAsync();
            CapturePaymentRequest capturePaymentRequest = JsonConvert.DeserializeObject <CapturePaymentRequest>(bodyAsText);

            if (string.IsNullOrWhiteSpace(privateKey) || string.IsNullOrWhiteSpace(publicKey))
            {
                return(BadRequest());
            }
            else
            {
                CapturePaymentResponse captureResponse = await this._affirmPaymentService.CapturePayment(capturePaymentRequest, publicKey, privateKey);

                _context.Vtex.Logger.Info("CapturePayment", null, $"{bodyAsText} {JsonConvert.SerializeObject(captureResponse)}");

                return(Json(captureResponse));
            }
        }
        /// <summary>
        /// Captures (settle) a payment that was previously approved.
        /// </summary>
        /// <param name="capturePaymentRequest"></param>
        /// <returns></returns>
        public async Task <CapturePaymentResponse> CapturePayment(CapturePaymentRequest capturePaymentRequest, string publicKey, string privateKey)
        {
            bool isLive = !capturePaymentRequest.sandboxMode; // await this.GetIsLiveSetting();
            CapturePaymentResponse capturePaymentResponse = new CapturePaymentResponse
            {
                message = "Unknown Error."
            };

            // Load request from storage for order id
            CreatePaymentRequest paymentRequest = await this._paymentRequestRepository.GetPaymentRequestAsync(capturePaymentRequest.paymentId);

            if (paymentRequest == null)
            {
                capturePaymentResponse.message = "Could not load Payment Request.";
                _context.Vtex.Logger.Info("CapturePayment", null, $"{capturePaymentResponse.message}");
            }
            else
            {
                // Get Affirm id from storage
                capturePaymentRequest.authorizationId = paymentRequest.transactionId;

                if (string.IsNullOrEmpty(capturePaymentRequest.authorizationId))
                {
                    capturePaymentResponse.message = "Missing authorizationId.";
                }
                else
                {
                    IAffirmAPI affirmAPI = new AffirmAPI(_httpContextAccessor, _httpClient, isLive, _context);
                    try
                    {
                        dynamic affirmResponse = await affirmAPI.CaptureAsync(publicKey, privateKey, capturePaymentRequest.authorizationId, paymentRequest.orderId, capturePaymentRequest.value, capturePaymentRequest.transactionId);

                        if (affirmResponse == null)
                        {
                            capturePaymentResponse.message = "Null affirmResponse.";
                            _context.Vtex.Logger.Warn("CapturePaymentResponse", null, $"{capturePaymentResponse.message}");
                        }
                        else
                        {
                            // If "Already Captured" then fake a success response.
                            if (affirmResponse.type != null && affirmResponse.type == AffirmConstants.AlreadyCaptured)
                            {
                                capturePaymentResponse = new CapturePaymentResponse
                                {
                                    paymentId = capturePaymentRequest.paymentId,
                                    settleId  = affirmResponse.id ?? affirmResponse.type,
                                    value     = affirmResponse.amount == null ? capturePaymentRequest.value : (decimal)affirmResponse.amount / 100m,
                                    code      = affirmResponse.type ?? null,                                                                                                                                                   //affirmResponse.Error.Code,
                                    message   = affirmResponse.id != null ? $"Fee={((affirmResponse.fee != null && affirmResponse.fee > 0) ? (decimal)affirmResponse.fee / 100m : 0):F2}" : affirmResponse.message ?? "Error", //: affirmResponse.Error.Message,
                                    requestId = capturePaymentRequest.requestId
                                };
                            }
                            else
                            {
                                capturePaymentResponse = new CapturePaymentResponse
                                {
                                    paymentId = capturePaymentRequest.paymentId,
                                    settleId  = affirmResponse.id ?? null,
                                    value     = affirmResponse.amount == null ? 0m : (decimal)affirmResponse.amount / 100m,
                                    code      = affirmResponse.type ?? null,                                                                                                                                                   //affirmResponse.Error.Code,
                                    message   = affirmResponse.id != null ? $"Fee={((affirmResponse.fee != null && affirmResponse.fee > 0) ? (decimal)affirmResponse.fee / 100m : 0):F2}" : affirmResponse.message ?? "Error", //: affirmResponse.Error.Message,
                                    requestId = capturePaymentRequest.requestId
                                };
                            }

                            if (capturePaymentRequest.authorizationId.StartsWith(AffirmConstants.KatapultIdPrefix))
                            {
                                // Need to get details from Katapult
                                VtexSettings vtexSettings = await _paymentRequestRepository.GetAppSettings();

                                if (vtexSettings.enableKatapult)
                                {
                                    capturePaymentResponse.value = affirmResponse.amount == null ? capturePaymentRequest.value : (decimal)affirmResponse.amount / 100m;
                                    KatapultFunding katapultResponse = await affirmAPI.KatapultFundingAsync(vtexSettings.katapultPrivateToken);

                                    if (katapultResponse != null)
                                    {
                                        FundingObject fundingObject = katapultResponse.FundingReport.FundingObjects.Where(f => f.OrderId.Equals(paymentRequest.orderId)).FirstOrDefault();
                                        capturePaymentResponse.message = JsonConvert.SerializeObject(fundingObject);
                                        _context.Vtex.Logger.Info("CapturePayment", null, $"Katapult Funding Response  {capturePaymentResponse.message}");
                                    }
                                    else
                                    {
                                        _context.Vtex.Logger.Info("CapturePayment", null, $"Katapult Funding Response was null.  [{capturePaymentRequest.authorizationId}]");
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _context.Vtex.Logger.Error("CapturePaymentAsync", null, $"CapturePaymentResponse:{ex.Message}", ex);
                        capturePaymentResponse.message = $"CapturePaymentAsync Error: {ex.Message}";
                    };
                }
            }

            return(capturePaymentResponse);
        }
 public CapturePaymentResponse Capture(CapturePaymentRequest capturePaymentRequest)
 {
     var result = new CapturePaymentResponse();
     result.AddError("Capture method not supported");
     return result;
 }