internal static Response ConvertTo(CaptureResponse captureResponse)
{
var response = new Response();
captureResponse.WriteBaseProperties(response);
var properties = new List <PaymentProperty>();
if (response.Properties != null)
{
properties.AddRange(response.Properties);
}
var captureRespnseProperties = new List <PaymentProperty>();
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.CardType, captureResponse.CardType);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.Last4Digits, captureResponse.Last4Digit);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.CardToken, captureResponse.CardToken);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.UniqueCardId, captureResponse.UniqueCardId);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.ProviderTransactionId, captureResponse.ProviderTransactionId);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.ApprovalCode, captureResponse.ApprovalCode);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.ResponseCode, captureResponse.ResponseCode);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.CurrencyCode, captureResponse.CurrencyCode);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.CaptureResult, captureResponse.CaptureResult);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.ProviderMessage, captureResponse.ProviderMessage);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.TransactionType, captureResponse.TransactionType);
PaymentUtilities.AddPropertyIfPresent(captureRespnseProperties, GenericNamespace.CaptureResponse, CaptureResponseProperties.TransactionDateTime, captureResponse.TransactionDateTime);
properties.Add(new PaymentProperty(GenericNamespace.CaptureResponse, CaptureResponseProperties.Properties, captureRespnseProperties.ToArray()));
response.Properties = properties.ToArray();
return(response);
}
public async Task CanGetMultiplePaymentActions()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
var captureRequest = new CaptureRequest
{
Reference = Guid.NewGuid().ToString()
};
CaptureResponse captureResponse = await _api.Payments.CaptureAsync(paymentResponse.Payment.Id, captureRequest);
IEnumerable <PaymentAction> actionsResponse = await _api.Payments.GetActionsAsync(paymentResponse.Payment.Id);
actionsResponse.ShouldNotBeNull();
PaymentAction authorizationPaymentAction = actionsResponse.SingleOrDefault(a => a.Type == ActionType.Authorization);
authorizationPaymentAction.ShouldNotBeNull();
authorizationPaymentAction.Id.ShouldBe(paymentResponse.Payment.ActionId);
PaymentAction capturePaymentAction = actionsResponse.SingleOrDefault(a => a.Type == ActionType.Capture);
capturePaymentAction.ShouldNotBeNull();
capturePaymentAction.Id.ShouldBe(captureResponse.ActionId);
capturePaymentAction.Reference.ShouldBe(captureResponse.Reference);
capturePaymentAction.Links.ShouldNotBeNull();
}
protected override void OnTarget(Mobile from, object targeted)
{
if (m_Paints.Deleted || !m_Paints.IsChildOf(from.Backpack))
{
return;
}
PlayerMobile player = from as PlayerMobile;
if (player != null)
{
QuestSystem qs = player.Quest;
if (qs is CollectorQuest)
{
CaptureImagesObjective obj = qs.FindObjective(typeof(CaptureImagesObjective)) as CaptureImagesObjective;
if (obj != null && !obj.Completed)
{
if (targeted is Mobile)
{
CaptureResponse response = obj.CaptureImage((targeted.GetType().Name == "GreaterMongbat" ? new Mongbat().GetType() : targeted.GetType()), out ImageType image);
switch (response)
{
case CaptureResponse.Valid:
{
player.SendLocalizedMessage(1055125); // The enchanted paints swirl for a moment then an image begins to take shape. *Click*
player.AddToBackpack(new PaintedImage(image));
break;
}
case CaptureResponse.AlreadyDone:
{
player.SendAsciiMessage(0x2C, "You have already captured the image of this creature");
break;
}
case CaptureResponse.Invalid:
{
player.SendLocalizedMessage(1055124); // You have no interest in capturing the image of this creature.
break;
}
}
}
else
{
player.SendAsciiMessage(0x35, "You have no interest in that.");
}
return;
}
}
}
from.SendLocalizedMessage(1010085); // You cannot use this.
}
public void CaptureSale_Error_Transaction()
{
var errorCreditCardCaptureResponse = new CaptureResponse
{
HttpStatus = HttpStatusCode.BadRequest,
Links = null,
ReasonCode = 0,
Status = 0,
ReasonMessage = null,
ErrorDataCollection = new List <Error>()
{
new Error
{
Code = 500,
Message = "Internal Server Error"
}
}
};
_mockRestClient.Setup(m => m.Execute <CaptureResponse>(It.IsAny <IRestRequest>())).Returns(new RestResponse <CaptureResponse>()
{
StatusCode = HttpStatusCode.BadRequest,
Content = new JsonSerializer().Serialize(errorCreditCardCaptureResponse),
Data = errorCreditCardCaptureResponse
});
var response = _service.Capture(Guid.NewGuid(), MerchantAuthenticationHelper.CreateMerchantAuthentication(), CaptureTransationHelper.CreateValidCaptureRequest());
response.ErrorDataCollection.Count.Should().BeGreaterThan(0);
response.HttpStatus.Should().Be(HttpStatusCode.BadRequest);
response.ReasonCode.Should().Be(0);
response.ReasonMessage.Should().BeNull();
response.Status.Should().Be(0);
response.Links.Should().BeNull();
}
public CaptureResponse Post(CaptureRequest req)
{
CaptureResponse response;
req.merchant_id = FondyConfig.MerchantId;
req.version = FondyConfig.Protocol;
req.signature = Signature.GetRequestSignature(RequiredParams.GetHashProperties(req));
try
{
response = Client.Invoke <CaptureRequest, CaptureResponse>(req, req.ActionUrl);
}
catch (ClientException c)
{
response = new CaptureResponse {
Error = c
};
}
if (response.data != null && FondyConfig.Protocol == "2.0")
{
return(JsonFormatter.ConvertFromJson <CaptureResponse>(response.data, true, "order"));
}
return(response);
}
public async void Run_SimpleCaptureTest()
{
ShowTestOnTerminal("SimpleCapture");
AuthorizationRequest setupRequest = new AuthorizationRequest
{
Pan = "4111111111111111",
ExpMonth = "12",
ExpYear = "2025",
Amount = "25.55",
Test = true,
};
output.WriteLine("Setup request: {0}", setupRequest);
AuthorizationResponse setupResponse = await blockchyp.PreauthAsync(setupRequest);
output.WriteLine("Setup Response: {0}", setupResponse);
CaptureRequest request = new CaptureRequest
{
TransactionId = setupResponse.TransactionId,
Test = true,
};
output.WriteLine("Request: {0}", request);
CaptureResponse response = await blockchyp.CaptureAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
Assert.True(response.Approved, "response.Approved");
}
private void MakePayment(OffAmazonPaymentsServiceAutomaticPaymentsSimpleCheckout automaticPayments,
string totalAmount, int indicator, bool captureNow)
{
lblNotification.Text += "<br>-----Making payment with indicator " + indicator.ToString() + "<br>";
/************************************************************************
* Invoke Authorize on Billing Agreement Action
***********************************************************************/
AuthorizeOnBillingAgreementResponse authResponse = automaticPayments.AuthorizeOnBillingAgreement(totalAmount, indicator, captureNow);
if (authResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from AuthorizeOnBillingAgreement request is null");
}
/************************************************************************
* Wait for the notification from ipn.aspx page in a loop, then print the corresponding information
***********************************************************************/
lblNotification.Text += formatStringForDisplay(WaitAndGetNotificationDetails(authResponse.AuthorizeOnBillingAgreementResult.AuthorizationDetails.AmazonAuthorizationId + "_Authorize"));
GetAuthorizationDetailsResponse response = automaticPayments.CheckAuthorizationStatus(authResponse);
/************************************************************************
* On an IPN callback, call GetAuthorizationDetails to retreive additional
* information about the authorization - this is done as part of the
* previous call to check the status.
***********************************************************************/
StringWriter stringWriter = new StringWriter();
GetAuthorizationDetailsSample.printGetAuthorizationDetailsResponseToBuffer(response, stringWriter);
lblNotification.Text += formatStringForDisplay(stringWriter.ToString());
if (!captureNow)
{
/************************************************************************
* Invoke Capture Action
***********************************************************************/
CaptureResponse captureResponse = automaticPayments.Capture(authResponse, totalAmount, indicator);
if (captureResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from Capture request is null");
}
/************************************************************************
* Wait for the notification from ipn.aspx page in a loop, then print the corresponding information
***********************************************************************/
lblNotification.Text += formatStringForDisplay(WaitAndGetNotificationDetails(captureResponse.CaptureResult.CaptureDetails.AmazonCaptureId + "_Capture"));
/************************************************************************
* Invoke Get Capture Details Action
***********************************************************************/
if (automaticPayments.GetCaptureDetail(captureResponse) == null)
{
throw new OffAmazonPaymentsServiceException("The response from GetCaptureDetail request is null");
}
}
lblNotification.Text += "-----Payment with indicator " + indicator.ToString() + " is complete<br><br>";
}
public async void Example()
{
#pragma warning disable 0168
using (Client client = GetClient())
{
CaptureResponse response = await client.Merchant("merchantId").Captures().Get("captureId");
}
#pragma warning restore 0168
}
public async Task CaptureFull_ServiceReturnsValidJson_ReturnsResponseInstance()
{
_messageHandler.SendAsyncReturns(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent("{\"capturedAmount\": 248.0000,\"authorizedAmount\": 248.0000,\"remainingAuthorizedAmount\": 0.0,\"captureNumber\": \"800007901\"}")
});
CaptureResponse result = await _service.CaptureFullAsync(Factory.GetString(), Factory.GetString());
Assert.IsType <CaptureResponse>(result);
}
public async void Example()
{
#pragma warning disable 0168
using (Client client = GetClient())
{
CapturePaymentRequest body = new CapturePaymentRequest();
body.Amount = 2980L;
CaptureResponse response = await client.Merchant("merchantId").Payments().Capture("paymentId", body);
}
#pragma warning restore 0168
}
public Output Capture(ref SecurityHeaderType Security, RequestHeaderType RequestHeader, Input Input)
{
CaptureRequest inValue = new CaptureRequest();
inValue.Security = Security;
inValue.RequestHeader = RequestHeader;
inValue.Input = Input;
CaptureResponse retVal = ((CaptureV02)(this)).Capture(inValue);
Security = retVal.Security;
return(retVal.Output);
}
public static Dictionary <string, string> CaptureApiCall()
{
string captureId = "";
string uniqueReferenceId = GenerateRandomUniqueString();
// If the captureNow was not true then capture the amount for the Authorization ID
if (!captureNow)
{
CaptureRequest captureRequestParameters = new CaptureRequest();
captureRequestParameters.WithAmazonAuthorizationId(amazonAuthorizationId)
// The below code can be used to get the amount from the session. the amount was added into session in the SetPaymentDetails.aspx
//.WithAmount(decimal.Parse(Session["amount"].ToString()))
//For example we will be authorizing amount value of 1.99
.WithAmount((decimal)1.99)
.WithCurrencyCode(Regions.currencyCode.USD)
.WithCaptureReferenceId(uniqueReferenceId)
.WithSellerCaptureNote("customNote");
CaptureResponse captureResponse = client.Capture(captureRequestParameters);
apiResponse["captureResponse"] = captureResponse.GetJson();
if (!captureResponse.GetSuccess())
{
// API CALL FAILED, get the Error code and Error Message
string errorCode = captureResponse.GetErrorCode();
string errorMessage = captureResponse.GetErrorMessage();
}
else
{
return(apiResponse);
}
}
else
{
// The captureNow was true therefore just disply the Captured response details
GetCaptureDetailsRequest getCaptureRequestParameters = new GetCaptureDetailsRequest();
foreach (string id in amazonCaptureIdList)
{
// Here there can be multiple Capture ID's. For example purposes we are considering a single Capture ID.
captureId = id;
}
getCaptureRequestParameters.WithAmazonCaptureId(captureId);
CaptureResponse getCaptureDetailsResponse = client.GetCaptureDetails(getCaptureRequestParameters);
apiResponse["captureResponse"] = getCaptureDetailsResponse.GetJson();
if (getCaptureDetailsResponse.GetSuccess())
{
return(apiResponse);
}
}
return(apiResponse);
}
public async Task Create()
{
var response = new CaptureResponse();
using (var api = new EbanxCaptureOperationApi())
{
var request = new CaptureRequest
{
};
response = await api.Create(request);
}
Assert.IsFalse(response.Success);
}
private static void MakePayment(OffAmazonPaymentsServiceAutomaticPaymentsSimpleCheckout automaticPayments,
string totalAmount, int indicator, bool captureNow)
{
Console.WriteLine("Making payment with indicator " + indicator.ToString());
Console.WriteLine("=============================================================================");
/************************************************************************
* Invoke Authorize on Billing Agreement Action
***********************************************************************/
AuthorizeOnBillingAgreementResponse authResponse = automaticPayments.AuthorizeOnBillingAgreement(totalAmount, indicator, captureNow);
if (authResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from AuthorizeOnBillingAgreement request is null");
}
Console.WriteLine("=============================================================================");
/************************************************************************
* Check the authorization status unitl it is not "PENDING" any more
* GetAuthorizationDetails is contained in this method
***********************************************************************/
automaticPayments.CheckAuthorizationStatus(authResponse);
if (!captureNow)
{
/************************************************************************
* Invoke Capture Action
***********************************************************************/
CaptureResponse captureResponse = automaticPayments.Capture(authResponse, totalAmount, indicator);
if (captureResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from Capture request is null");
}
Console.WriteLine("=============================================================================");
/************************************************************************
* Invoke Get Capture Details Action
***********************************************************************/
if (automaticPayments.GetCaptureDetail(captureResponse) == null)
{
throw new OffAmazonPaymentsServiceException("The response from GetCaptureDetail request is null");
}
Console.WriteLine("=============================================================================");
}
Console.WriteLine("Payment with indicator " + indicator.ToString() + " is complete");
Console.WriteLine("=============================================================================");
}
public void CaptureApiCall()
{
string captureId = "";
string uniqueReferenceId = GenerateRandomUniqueString();
// If the capture has not happened on the previous Authorize API call then capture the amount.
if (!captureNow)
{
CaptureRequest captureRequestParameters = new CaptureRequest();
captureRequestParameters.WithAmazonAuthorizationId(amazonAuthorizationId)
.WithAmount(decimal.Parse(Session["amount"].ToString()))
.WithCurrencyCode(Regions.currencyCode.USD)
.WithCaptureReferenceId(uniqueReferenceId)
.WithSellerCaptureNote("customNote");
CaptureResponse captureResponse = client.Capture(captureRequestParameters);
// Capture was not a success Get the Error code and the Error message
if (!captureResponse.GetSuccess())
{
string errorCode = captureResponse.GetErrorCode();
string errorMessage = captureResponse.GetErrorMessage();
capture.InnerHtml = "Capture API call Failed" + Environment.NewLine + captureResponse.GetJson();
}
else
{
// In this example the below is to simply display the output
capture.InnerHtml = captureResponse.GetJson();
}
}
else
{
// In this case the capture had already happened . running the GetCaptureDetails API call to get the output of the capture.
GetCaptureDetailsRequest getCaptureRequestParameters = new GetCaptureDetailsRequest();
foreach (string id in amazonCaptureIdList)
{
captureId = id;
}
getCaptureRequestParameters.WithAmazonCaptureId(captureId);
CaptureResponse getCaptureDetailsResponse = client.GetCaptureDetails(getCaptureRequestParameters);
if (getCaptureDetailsResponse.GetSuccess())
{
capture.InnerHtml = getCaptureDetailsResponse.GetJson();
}
}
}
private async Task ShouldCapturePayment_IdempotencyKey()
{
var captureResponse = new CaptureResponse();
_apiClient.Setup(apiClient =>
apiClient.Post <CaptureResponse>(PaymentsPath + "/payment_id/captures", _authorization,
null,
CancellationToken.None, "test"))
.ReturnsAsync(() => captureResponse);
IPaymentsClient paymentsClient = new PaymentsClient(_apiClient.Object, _configuration.Object);
var response = await paymentsClient.CapturePayment("payment_id", null, "test");
response.ShouldNotBeNull();
}
private async Task ShouldCapturePayment()
{
var orderCaptureRequest = new OrderCaptureRequest();
var captureResponse = new CaptureResponse();
_apiClient.Setup(apiClient =>
apiClient.Post <CaptureResponse>("klarna-external/orders/id/captures", _authorization,
orderCaptureRequest,
CancellationToken.None, null))
.ReturnsAsync(() => captureResponse);
var klarnaClient = new KlarnaClient(_apiClient.Object, _configuration.Object);
var response = await klarnaClient.CapturePayment("id", orderCaptureRequest, CancellationToken.None);
response.ShouldNotBeNull();
}
private AmazonPayData GetDetails(CaptureResponse response)
{
var data = new AmazonPayData();
data.MessageType = "GetCaptureDetails";
data.MessageId = response.GetRequestId();
data.CaptureId = response.GetCaptureId();
data.ReferenceId = response.GetCaptureReferenceId();
data.Fee = new AmazonPayPrice(response.GetCaptureFee(), response.GetCaptureFeeCurrencyCode());
data.CapturedAmount = new AmazonPayPrice(response.GetCaptureAmount(), response.GetCaptureAmountCurrencyCode());
data.Creation = response.GetCreationTimestamp();
data.ReasonCode = response.GetReasonCode();
data.ReasonDescription = response.GetReasonDescription();
data.State = response.GetCaptureState();
data.StateLastUpdate = response.GetLastUpdatedTimestamp();
return(data);
}
/// <summary>
/// Parse the Notification into API Response objects.
/// </summary>
private void GetIpnResponseObjects()
{
string xml;
xml = this.ToXml();
if (Enum.IsDefined(typeof(NotificationType), this.GetNotificationType()))
{
switch ((NotificationType)Enum.Parse(typeof(NotificationType), this.GetNotificationType()))
{
case NotificationType.OrderReferenceNotification:
orderReferenceDetailsObject = new OrderReferenceDetailsResponse(xml);
break;
case NotificationType.BillingAgreementNotification:
billingAgreementDetailsObject = new BillingAgreementDetailsResponse(xml);
break;
case NotificationType.PaymentAuthorize:
authorizeResponseObject = new AuthorizeResponse(xml);
break;
case NotificationType.PaymentCapture:
captureResponseObject = new CaptureResponse(xml);
break;
case NotificationType.PaymentRefund:
refundResponseObject = new RefundResponse(xml);
break;
case NotificationType.ProviderCredit:
providerCreditResponseObject = new GetProviderCreditDetailsResponse(xml);
break;
case NotificationType.ProviderCreditReversal:
providerCreditReversalResponseObject = new GetProviderCreditReversalDetailsResponse(xml);
break;
case NotificationType.ChargebackDetailedNotification:
chargebackResponseObject = new ChargebackResponse(xml);
break;
}
}
}
public CaptureResponse Capture(CaptureRequest captureRequest)
{
CaptureResponse respose;
if (_repo.TryGetAuthorization(captureRequest.AuthorizationId, out var authorization))
{
if (IsCaptureAllowed(authorization))
{
if (authorization.AmountCaptured + captureRequest.Amount <= authorization.AmountAuthorized)
{
_repo.UpdateCapture(captureRequest.AuthorizationId, captureRequest.Amount);
respose = new CaptureResponse(authorization.Currency, captureRequest.Amount)
{
Message = $"{authorization.CardNumber} - Successfully captured {authorization.Currency} {captureRequest.Amount}"
};
}
else
{
respose = new CaptureResponse(authorization.Currency, captureRequest.Amount)
{
IsError = true, Message = $"{authorization.CardNumber} - Failed to capture {authorization.Currency} {captureRequest.Amount} as it exceeds authorized amount"
};
}
}
else
{
respose = new CaptureResponse(authorization.Currency, captureRequest.Amount)
{
IsError = true, Message = $"{authorization.CardNumber} - Capture not allowed on a void/refunded transaction"
};
}
return(respose);
}
else
{
respose = new CaptureResponse(string.Empty, captureRequest.Amount)
{
IsError = true, Message = $"Capture failed. Invalid authorization Id: {captureRequest.AuthorizationId}"
};
return(respose);
}
}
public async Task GetCaptureAsync_DefaultBehaviour_ResponseIsParsed()
{
// Given: We request a capture with a payment id and capture id
string expectedUrl = $"{BaseMollieClient.ApiEndPoint}payments/{defaultPaymentId}/captures/{defaultCaptureId}";
var mockHttp = this.CreateMockHttpMessageHandler(HttpMethod.Get, expectedUrl, defaultCaptureJsonResponse);
HttpClient httpClient = mockHttp.ToHttpClient();
CaptureClient captureClient = new CaptureClient("api-key", httpClient);
// When: We make the request
CaptureResponse captureResponse = await captureClient.GetCaptureAsync(defaultPaymentId, defaultCaptureId);
// Then: Response should be parsed
mockHttp.VerifyNoOutstandingExpectation();
Assert.IsNotNull(captureResponse);
Assert.AreEqual(defaultPaymentId, captureResponse.PaymentId);
Assert.AreEqual(defaultShipmentId, captureResponse.ShipmentId);
Assert.AreEqual(defaultSettlementId, captureResponse.SettlementId);
Assert.AreEqual(defaultAmountValue, captureResponse.Amount.Value);
Assert.AreEqual(defaultAmountCurrency, captureResponse.Amount.Currency);
}
public CaptureResponse Capture(Guid paymentId, MerchantAuthentication merchantAuthentication, CaptureRequest captureRequest)
{
var restRequest = new RestRequest(@"sales/{paymentId}/capture", Method.PUT)
{
RequestFormat = DataFormat.Json
};
AddHeaders(restRequest, merchantAuthentication);
restRequest.AddUrlSegment("paymentId", paymentId.ToString());
if (captureRequest != null)
{
restRequest.AddQueryParameter("amount", captureRequest.Amount.ToString());
restRequest.AddQueryParameter("serviceTaxAmount", captureRequest.ServiceTaxAmount.ToString());
}
var response = RestClient.Execute <CaptureResponse>(restRequest);
CaptureResponse captureResponse = null;
if (response.StatusCode == HttpStatusCode.OK)
{
captureResponse = JsonConvert.DeserializeObject <CaptureResponse>(response.Content);
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
captureResponse = new CaptureResponse {
ErrorDataCollection = JsonDeserializer.Deserialize <List <Error> >(response)
}
}
;
else
{
captureResponse = new CaptureResponse();
}
captureResponse.HttpStatus = response.StatusCode;
return(captureResponse);
}
public async Task ListSettlementCaptures_DefaultBehaviour_ResponseIsParsed()
{
// Given: We request a list of captures
string expectedUrl = $"{BaseMollieClient.ApiEndPoint}settlements/{defaultSettlementId}/captures";
var mockHttp = this.CreateMockHttpMessageHandler(HttpMethod.Get, expectedUrl, defaultCaptureListJsonResponse);
HttpClient httpClient = mockHttp.ToHttpClient();
SettlementsClient settlementsClient = new SettlementsClient("api-key", httpClient);
// When: We make the request
ListResponse <CaptureResponse> listCaptureResponse = await settlementsClient.ListSettlementCapturesAsync(defaultSettlementId);
// Then: Response should be parsed
mockHttp.VerifyNoOutstandingExpectation();
Assert.IsNotNull(listCaptureResponse);
Assert.AreEqual(1, listCaptureResponse.Count);
CaptureResponse captureResponse = listCaptureResponse.Items.First();
Assert.AreEqual(defaultPaymentId, captureResponse.PaymentId);
Assert.AreEqual(defaultShipmentId, captureResponse.ShipmentId);
Assert.AreEqual(defaultSettlementId, captureResponse.SettlementId);
Assert.AreEqual(defaultAmountValue, captureResponse.Amount.Value);
Assert.AreEqual(defaultAmountCurrency, captureResponse.Amount.Currency);
}
protected void Page_Load(object sender, EventArgs e)
{
System.Globalization.CultureInfo ui = System.Globalization.CultureInfo.CurrentUICulture;
if (Request.Form["payment_id"] != null || Request.Form["data"] != null)
{
var resp = new Response().GetResponse(Request.Form.ToString(), "form");
ResponeData = resp;
if (resp.SignatureError != null)
{
ResponeOrderError = "Signature error";
ResponeOrderSignatureString = resp.SignatureError.SignatureString;
ResponeOrderCalculatedSignatureString = resp.SignatureError.CalculatedSignature;
}
else
{
ResponeOrder = resp.order_id;
var captureReq = new CaptureRequest
{
order_id = resp.order_id,
amount = Convert.ToInt32(resp.amount) - 1,
currency = "USD",
};
var cresp = new Capture().Post(captureReq);
if (cresp.Error != null)
{
ResponeData = null;
DataError = cresp.Error.ErrorMessage;
Data = cresp.Error.RequestId;
}
else
{
CaptureResp = cresp;
}
}
}
btnSubmit.Click += Submit;
}
public override string CaptureOrder(Order o)
{
String result = String.Empty;
o.CaptureTXCommand = "";
o.CaptureTXResult = "";
// check for ReauthorizationID first, if doesn't exist, use original AuthorizationID
String TransID = Regex.Match(o.AuthorizationPNREF, "(?<=REAU=)[0-9A-Z]+", RegexOptions.Compiled).ToString();
if (TransID.Length == 0)
{
TransID = Regex.Match(o.AuthorizationPNREF, "(?<=AUTH=)[0-9A-Z]+", RegexOptions.Compiled).ToString();
}
Decimal OrderTotal = o.OrderBalance;
if (TransID.Length == 0 || TransID == "0")
{
result = "Invalid or Empty Transaction ID";
}
else
{
try
{
DoCaptureReq CaptureReq = new DoCaptureReq();
DoCaptureRequestType CaptureRequestType = new DoCaptureRequestType();
DoCaptureResponseType CaptureResponse;
BasicAmountType totalAmount = new BasicAmountType();
totalAmount.Value = Localization.CurrencyStringForGatewayWithoutExchangeRate(OrderTotal);
totalAmount.currencyID = (CurrencyCodeType)Enum.Parse(typeof(CurrencyCodeType), AppLogic.AppConfig("Localization.StoreCurrency"), true);
CaptureRequestType.Amount = totalAmount;
CaptureRequestType.AuthorizationID = TransID;
CaptureRequestType.CompleteType = CompleteCodeType.Complete;
CaptureRequestType.Version = API_VER;
CaptureReq.DoCaptureRequest = CaptureRequestType;
o.CaptureTXCommand = XmlCommon.SerializeObject(CaptureReq, CaptureReq.GetType()); //"Not Available For PayPal";
CaptureResponse = (DoCaptureResponseType)IPayPal.DoCapture(CaptureReq);
//if (LogToErrorTable)
//{
// PayPalController.Log(XmlCommon.SerializeObject(CaptureReq, CaptureReq.GetType()), "DoCapture Request");
// PayPalController.Log(XmlCommon.SerializeObject(CaptureResponse, CaptureResponse.GetType()), "DoCapture Response");
//}
o.CaptureTXResult = XmlCommon.SerializeObject(CaptureResponse, CaptureResponse.GetType());
if (CaptureResponse != null && CaptureResponse.Ack.ToString().StartsWith("success", StringComparison.InvariantCultureIgnoreCase))
{
result = AppLogic.ro_OK;
String CaptureTransID = CaptureResponse.DoCaptureResponseDetails.PaymentInfo.TransactionID;
o.AuthorizationPNREF = o.AuthorizationPNREF + "|CAPTURE=" + CaptureTransID;
}
else
{
if (CaptureResponse.Errors != null)
{
bool first = true;
for (int ix = 0; ix < CaptureResponse.Errors.Length; ix++)
{
if (!first)
{
result += ", ";
}
result += "Error: [" + CaptureResponse.Errors[ix].ErrorCode + "] " + CaptureResponse.Errors[ix].LongMessage;
first = false;
}
}
}
}
catch
{
result = "NO RESPONSE FROM GATEWAY!";
}
}
return(result);
}
public static CaptureResponse InvokeCapture(IOffAmazonPaymentsService service, CaptureRequest request)
{
CaptureResponse response = null;
try
{
response = service.Capture(request);
Console.WriteLine("Service Response");
Console.WriteLine("=============================================================================");
Console.WriteLine();
Console.WriteLine(" CaptureResponse");
if (response.IsSetCaptureResult())
{
Console.WriteLine(" CaptureResult");
CaptureResult captureResult = response.CaptureResult;
if (captureResult.IsSetCaptureDetails())
{
Console.WriteLine(" CaptureDetails");
CaptureDetails captureDetails = captureResult.CaptureDetails;
if (captureDetails.IsSetAmazonCaptureId())
{
Console.WriteLine(" AmazonCaptureId");
Console.WriteLine(" {0}", captureDetails.AmazonCaptureId);
}
if (captureDetails.IsSetCaptureReferenceId())
{
Console.WriteLine(" CaptureReferenceId");
Console.WriteLine(" {0}", captureDetails.CaptureReferenceId);
}
if (captureDetails.IsSetSellerCaptureNote())
{
Console.WriteLine(" SellerCaptureNote");
Console.WriteLine(" {0}", captureDetails.SellerCaptureNote);
}
if (captureDetails.IsSetCaptureAmount())
{
Console.WriteLine(" CaptureAmount");
Price captureAmount = captureDetails.CaptureAmount;
if (captureAmount.IsSetAmount())
{
Console.WriteLine(" Amount");
Console.WriteLine(" {0}", captureAmount.Amount);
}
if (captureAmount.IsSetCurrencyCode())
{
Console.WriteLine(" CurrencyCode");
Console.WriteLine(" {0}", captureAmount.CurrencyCode);
}
}
if (captureDetails.IsSetRefundedAmount())
{
Console.WriteLine(" RefundedAmount");
Price refundedAmount = captureDetails.RefundedAmount;
if (refundedAmount.IsSetAmount())
{
Console.WriteLine(" Amount");
Console.WriteLine(" {0}", refundedAmount.Amount);
}
if (refundedAmount.IsSetCurrencyCode())
{
Console.WriteLine(" CurrencyCode");
Console.WriteLine(" {0}", refundedAmount.CurrencyCode);
}
}
if (captureDetails.IsSetCaptureFee())
{
Console.WriteLine(" CaptureFee");
Price captureFee = captureDetails.CaptureFee;
if (captureFee.IsSetAmount())
{
Console.WriteLine(" Amount");
Console.WriteLine(" {0}", captureFee.Amount);
}
if (captureFee.IsSetCurrencyCode())
{
Console.WriteLine(" CurrencyCode");
Console.WriteLine(" {0}", captureFee.CurrencyCode);
}
}
if (captureDetails.IsSetCreationTimestamp())
{
Console.WriteLine(" CreationTimestamp");
Console.WriteLine(" {0}", captureDetails.CreationTimestamp);
}
if (captureDetails.IsSetProviderCreditSummaryList())
{
Console.WriteLine(" ProviderCreditSummaryList");
foreach (ProviderCreditSummary providerCreditSummary in captureDetails.ProviderCreditSummaryList.member)
{
if (providerCreditSummary.IsSetProviderCreditId())
{
Console.WriteLine(" ProviderCreditId");
Console.WriteLine(" {0}", providerCreditSummary.ProviderCreditId);
}
if (providerCreditSummary.IsSetProviderId())
{
Console.WriteLine(" ProviderId");
Console.WriteLine(" {0}", providerCreditSummary.ProviderId);
}
}
}
if (captureDetails.IsSetCaptureStatus())
{
Console.WriteLine(" CaptureStatus");
Status captureStatus = captureDetails.CaptureStatus;
if (captureStatus.IsSetState())
{
Console.WriteLine(" State");
Console.WriteLine(" {0}", captureStatus.State);
}
if (captureStatus.IsSetLastUpdateTimestamp())
{
Console.WriteLine(" LastUpdateTimestamp");
Console.WriteLine(" {0}", captureStatus.LastUpdateTimestamp);
}
if (captureStatus.IsSetReasonCode())
{
Console.WriteLine(" ReasonCode");
Console.WriteLine(" {0}", captureStatus.ReasonCode);
}
if (captureStatus.IsSetReasonDescription())
{
Console.WriteLine(" ReasonDescription");
Console.WriteLine(" {0}", captureStatus.ReasonDescription);
}
}
}
}
if (response.IsSetResponseMetadata())
{
Console.WriteLine(" ResponseMetadata");
ResponseMetadata responseMetadata = response.ResponseMetadata;
if (responseMetadata.IsSetRequestId())
{
Console.WriteLine(" RequestId");
Console.WriteLine(" {0}", responseMetadata.RequestId);
}
}
Console.WriteLine();
}
catch (OffAmazonPaymentsServiceException ex)
{
PrintException(ex);
}
return(response);
}
private void RunSampleMultiShipments(string orderAmount, OffAmazonPaymentsServiceMultipleShipment instance)
{
/************************************************************************
* Invoke Get Order Reference Details Action
***********************************************************************/
GetOrderReferenceDetailsResponse getOrderDetails = instance.GetOrderReferenceDetails();
if (getOrderDetails == null)
{
throw new OffAmazonPaymentsServiceException("The response from GetOrderReference request is null");
}
Address address = getOrderDetails.GetOrderReferenceDetailsResult.OrderReferenceDetails.Destination.PhysicalDestination;
lblShipping.Text = "The shipping address is: " + address.City + "<br>" + address.StateOrRegion + "<br>" + address.PostalCode + "<br>";
/************************************************************************
* Invoke Set Order Reference Details Action
***********************************************************************/
SetOrderReferenceDetailsResponse setOrderDetailsResponse = instance.SetOrderReferenceDetails(orderAmount);
if (setOrderDetailsResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from SetOrderReference request is null");
}
/************************************************************************
* Invoke Confirm Order Reference Action
***********************************************************************/
if (instance.ConfirmOrderReferenceObject() == null)
{
throw new OffAmazonPaymentsServiceException("The response from ConfirmOrderResponse request is null");
}
//iterate the authoriztion amount in the authList
for (int i = 0; i < numberOfShipment; i++)
{
String eachOrderAmount = amountEachShip[i].ToString();
/************************************************************************
* Invoke Authorize Action
***********************************************************************/
AuthorizeResponse authResponse = instance.AuthorizeAction(eachOrderAmount, indicator);
if (authResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from Authorization Response request is null");
}
/************************************************************************
* Wait for the notification from ipn.aspx page in a loop, then print the corresponding information
***********************************************************************/
lblNotification.Text += WaitAndGetNotificationDetails(authResponse.AuthorizeResult.AuthorizationDetails.AmazonAuthorizationId + "_Authorize");
instance.CheckAuthorizationStatus(authResponse);
/************************************************************************
* Invoke Capture Action
***********************************************************************/
CaptureResponse captureResponse = instance.CaptureAction(authResponse, eachOrderAmount, indicator);
if (captureResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from Caputre Response request is null");
}
lblNotification.Text += WaitAndGetNotificationDetails(captureResponse.CaptureResult.CaptureDetails.AmazonCaptureId + "_Capture");
/************************************************************************
* Invoke Get Capture Details Action
***********************************************************************/
if (instance.GetCaptureDetails(captureResponse) == null)
{
throw new OffAmazonPaymentsServiceException("The response from GetCaputreDetails Response request is null");
}
indicator++;
}
/************************************************************************
* Invoke Close Order Reference Action
***********************************************************************/
if (instance.CloseOrderReference() == null)
{
throw new OffAmazonPaymentsServiceException("The response from CloseOrderReference Response request is null");
}
lblNotification.Text += WaitAndGetNotificationDetails(orderReferenceId + "_OrderReference");
}
private static void RunSampleMultiShipments(string orderReferenceId, string orderAmount, OffAmazonPaymentsServiceMultipleShipment instance)
{
/************************************************************************
* Invoke Get Order Reference Details Action
***********************************************************************/
GetOrderReferenceDetailsResponse getOrderDetails = instance.GetOrderReferenceDetails();
if (getOrderDetails == null)
{
throw new OffAmazonPaymentsServiceException("The response from GetOrderReference request is null");
}
Console.WriteLine("=======================================================");
/************************************************************************
* Invoke Set Order Reference Details Action
***********************************************************************/
SetOrderReferenceDetailsResponse setOrderDetailsResponse = instance.SetOrderReferenceDetails(orderAmount);
if (setOrderDetailsResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from SetOrderReference request is null");
}
Console.WriteLine("=======================================================");
/************************************************************************
* Invoke Confirm Order Reference Action
***********************************************************************/
if (instance.ConfirmOrderReferenceObject() == null)
{
throw new OffAmazonPaymentsServiceException("The response from ConfirmOrderResponse request is null");
}
Console.WriteLine("=======================================================");
Console.WriteLine("===========================================");
Console.WriteLine("Here is the demo of one capture per authorization.");
Console.WriteLine("===========================================");
Console.WriteLine();
IDictionary <string, OrderItem> orderList = instance.OrderList;
Console.WriteLine("Current orders are listed as below: ");
instance.ShowCurrentOrders();
System.Threading.Thread.Sleep(3000);
//iterate the authoriztion amount in the authList
foreach (string item in orderList.Keys)
{
String eachOrderAmount = (orderList[item].Price * orderList[item].Number).ToString();
/************************************************************************
* Invoke Authorize Action
***********************************************************************/
AuthorizeResponse authResponse = instance.AuthorizeAction(eachOrderAmount, indicator);
if (authResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from Authorization Response request is null");
}
Console.WriteLine("=======================================================");
/************************************************************************
* Check the authorization status unitl it is not "PENDING" any more
* GetAuthorizeDetails is contained in this method
***********************************************************************/
instance.CheckAuthorizationStatus(authResponse);
/************************************************************************
* Invoke Capture Action
***********************************************************************/
CaptureResponse captureResponse = instance.CaptureAction(authResponse, eachOrderAmount, indicator);
if (captureResponse == null)
{
throw new OffAmazonPaymentsServiceException("The response from Caputre Response request is null");
}
Console.WriteLine("=======================================================");
/************************************************************************
* Invoke GetCaptureDetails Action
***********************************************************************/
if (instance.GetCaptureDetails(captureResponse) == null)
{
throw new OffAmazonPaymentsServiceException("The response from GetCaputreDetails Response request is null");
}
Console.WriteLine("=======================================================");
indicator++;
}
/************************************************************************
* Invoke CloseOrderReference Action
***********************************************************************/
if (instance.CloseOrderReference() == null)
{
throw new OffAmazonPaymentsServiceException("The response from CloseOrderReference Response request is null");
}
}
//Invoke the GetCaptureDetails method
public GetCaptureDetailsResponse GetCaptureDetails(CaptureResponse captureReponse)
{
return(GetCaptureDetailsSample.GetCaptureDetails(propertiesCollection, service, captureReponse.CaptureResult.CaptureDetails.AmazonCaptureId));
}
//Use a loop to check for the ProviderCreditSummaryList in the CaptureDetails. Once found, return it.
public ProviderCreditSummaryList CheckCaptureForProviderCreditSummaryList(CaptureResponse captureResponse)
{
return GetCaptureDetailsSample.CheckCaptureForProviderCreditSummaryList(captureResponse.CaptureResult.CaptureDetails.AmazonCaptureId, propertiesCollection, service);
}
//Invoke the GetCaptureDetails method
public GetCaptureDetailsResponse GetCaptureDetails(CaptureResponse captureReponse)
{
return GetCaptureDetailsSample.GetCaptureDetails(propertiesCollection, service, captureReponse.CaptureResult.CaptureDetails.AmazonCaptureId);
}
public static void Thread1(object sock)
{
string gatewayPrivateKey = File.ReadAllText("d:/file/gatewayPrivateKey.xml");
X509Certificate2 caCertificate = new X509Certificate2("d:/file/ca.crt");
X509Certificate2 gatewayCertificate = new X509Certificate2("d:/file/gateway.crt");
X509Certificate2 issuerCertificate = new X509Certificate2("d:/file/issuer.crt");
X509Certificate2 customerCertificate, merchantCertificate;
string sendMessage;
Common c = new Common();
Socket socket = (Socket)sock;
//nhận auth request
string receiveMessage = c.receive(ref socket);
string[] tam = receiveMessage.Split('-');
customerCertificate = new X509Certificate2(c.StringToByteArray(tam[4]));
merchantCertificate = new X509Certificate2(c.StringToByteArray(tam[5]));
if (c.VerifyCertificate(caCertificate, customerCertificate) == false || c.VerifyCertificate(caCertificate, merchantCertificate) == false)
{
Console.WriteLine("verify authorization request certificate false");
string message = "ERROR" + "-" + 4 + "-" + "xac thuc that bai";
c.send(message, ref socket);
}
else
{
AuthorizationRequest authorizationRequest = new AuthorizationRequest(tam[0], tam[1], tam[2], tam[3], tam[4], tam[5], tam[6]);
if (authorizationRequest.Verify(gatewayPrivateKey) == false)
{
Console.WriteLine("verify authorization request false");
string s = "ERROR" + "-" + 4 + "-" + "xac thuc that bai";
c.send(s, ref socket);
}
else
{
Console.WriteLine("verify authorization request true");
//chuyển auth request đến issuer
string issuerPublicKey = issuerCertificate.GetRSAPublicKey().ToXmlString(false);
string PI = authorizationRequest.getPI(gatewayPrivateKey);
string[] splitPI = PI.Split(':');
PaymentInstructions paymentInstructions = new PaymentInstructions(splitPI[0], splitPI[1], splitPI[2], splitPI[3], splitPI[4], splitPI[5], Convert.ToInt64(splitPI[6]));
string RRPID = paymentInstructions.getRRPID();
paymentInstructions.setRRPID(c.Random(2));
ForwardAuthorizationRequest forwardAuthorization = new ForwardAuthorizationRequest(paymentInstructions.PIToString(), issuerPublicKey);
sendMessage = forwardAuthorization.ToMessage();
//kết nối issuer
IPEndPoint iep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1236);
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
client.Connect(iep);
c.send(sendMessage, ref client);
//nhận kq response từ issuer
receiveMessage = c.receive(ref client);
string[] splitRES = receiveMessage.Split('-');
issuerCertificate = new X509Certificate2(c.StringToByteArray(splitRES[2]));
if (c.VerifyCertificate(caCertificate, issuerCertificate) == true)
{
Console.WriteLine("verify authorization response certificate from issuer true");
issuerPublicKey = issuerCertificate.GetRSAPublicKey().ToXmlString(false);
bool verifyRES = c.Verify(issuerPublicKey, splitRES[1], splitRES[0]);
if (verifyRES == true)
{
Console.WriteLine("verify authorization response from issuer true");
//tạo và gửi auth response
string[] splitIssuerRES = splitRES[0].Split(':');
//kiểm tra response từ issuer có ERROR hay không
if (splitIssuerRES[0].CompareTo("ERROR") == 0)
{
string message = splitIssuerRES[0] + ":" + RRPID + ":" + splitIssuerRES[1] + ":" + splitIssuerRES[2];
X509Certificate2 certificate2 = new X509Certificate2(c.StringToByteArray(authorizationRequest.getMerchantCertificate()));
string publicKeyMerchant = certificate2.GetRSAPublicKey().ToXmlString(false);
AuthorizationResponse authorizationResponse = new AuthorizationResponse(message, publicKeyMerchant);
c.send(authorizationResponse.ToMessageNoToken(), ref socket);
}
else
{
string message = splitIssuerRES[0] + ":" + RRPID + ":" + splitIssuerRES[1] + ":" + splitIssuerRES[2];
CaptureToken token = new CaptureToken(paymentInstructions.getTransID(), paymentInstructions.getCardNumber(), paymentInstructions.getTien());
X509Certificate2 certificate2 = new X509Certificate2(c.StringToByteArray(authorizationRequest.getMerchantCertificate()));
string publicKeyMerchant = certificate2.GetRSAPublicKey().ToXmlString(false);
AuthorizationResponse authorizationResponse = new AuthorizationResponse(message, publicKeyMerchant);
authorizationResponse.setCaptureToken(token.ToMessage());
c.send(authorizationResponse.ToMessage(), ref socket);
//nhận capture request
receiveMessage = c.receive(ref socket);
string[] splitCapture = receiveMessage.Split('-');
merchantCertificate = new X509Certificate2(c.StringToByteArray(splitCapture[6]));
if (c.VerifyCertificate(caCertificate, merchantCertificate) == false)
{
Console.WriteLine("verify capture request certificate false");
string message1 = "ERROR" + "-" + 4 + "-" + "xac thuc that bai";
c.send(message1, ref socket);
}
else
{
Console.WriteLine("verify capture request certificate true");
CaptureRequest captureRequest = new CaptureRequest(splitCapture[0], splitCapture[1], splitCapture[2], splitCapture[3], splitCapture[4], splitCapture[5], splitCapture[6]);
if (captureRequest.Verify() == false)
{
Console.WriteLine("verify capture request false");
message = "ERROR" + "-" + 4 + "-" + "xac thuc that bai";
c.send(message, ref socket);
}
else
{
Console.WriteLine("verify capture request true");
//chuyển capture request tới issuer
sendMessage = captureRequest.messageToIssuer();
c.send(sendMessage, ref client);
//nhận message từ issuer
receiveMessage = c.receive(ref client);
string[] splitCaptureRES = receiveMessage.Split('-');
issuerCertificate = new X509Certificate2(c.StringToByteArray(splitCaptureRES[2]));
if (c.VerifyCertificate(caCertificate, issuerCertificate) == true)
{
Console.WriteLine("verify capture response certificate from issuer true");
issuerCertificate = new X509Certificate2(c.StringToByteArray(splitCaptureRES[2]));
issuerPublicKey = issuerCertificate.GetRSAPublicKey().ToXmlString(false);
if (c.Verify(issuerPublicKey, splitCaptureRES[1], splitCaptureRES[0]) == true)
{
Console.WriteLine("verify capture response from issuer true");
//tạo capture response gừi tới merchant
string[] split = splitCaptureRES[0].Split(':');
message = split[0] + ":" + captureRequest.getRRPID() + ":" + split[1] + ":" + split[2];
CaptureResponse captureResponse = new CaptureResponse(message, publicKeyMerchant);
c.send(captureResponse.ToMessage(), ref socket);
}
}
client.Close();
}
}
}
}
}
}
}
socket.Close();
}
