com.ingenico.connect.gateway.sdk.java.merchant.payments.PaymentsClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of connect-sdk-java Show documentation
Show all versions of connect-sdk-java Show documentation
SDK to communicate with the Ingenico ePayments platform using the Ingenico Connect Server API
/*
* This class was auto-generated from the API references found at
* https://epayments-api.developer-ingenico.com/s2sapi/v1/
*/
package com.ingenico.connect.gateway.sdk.java.merchant.payments;
import java.util.Map;
import java.util.TreeMap;
import com.ingenico.connect.gateway.sdk.java.ApiException;
import com.ingenico.connect.gateway.sdk.java.ApiResource;
import com.ingenico.connect.gateway.sdk.java.AuthorizationException;
import com.ingenico.connect.gateway.sdk.java.CallContext;
import com.ingenico.connect.gateway.sdk.java.DeclinedPaymentException;
import com.ingenico.connect.gateway.sdk.java.DeclinedRefundException;
import com.ingenico.connect.gateway.sdk.java.GlobalCollectException;
import com.ingenico.connect.gateway.sdk.java.IdempotenceException;
import com.ingenico.connect.gateway.sdk.java.ReferenceException;
import com.ingenico.connect.gateway.sdk.java.ResponseException;
import com.ingenico.connect.gateway.sdk.java.ValidationException;
import com.ingenico.connect.gateway.sdk.java.domain.capture.CaptureResponse;
import com.ingenico.connect.gateway.sdk.java.domain.capture.CapturesResponse;
import com.ingenico.connect.gateway.sdk.java.domain.dispute.CreateDisputeRequest;
import com.ingenico.connect.gateway.sdk.java.domain.dispute.DisputeResponse;
import com.ingenico.connect.gateway.sdk.java.domain.dispute.DisputesResponse;
import com.ingenico.connect.gateway.sdk.java.domain.errors.ErrorResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.ApprovePaymentRequest;
import com.ingenico.connect.gateway.sdk.java.domain.payment.CancelApprovalPaymentResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.CancelPaymentResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.CapturePaymentRequest;
import com.ingenico.connect.gateway.sdk.java.domain.payment.CompletePaymentRequest;
import com.ingenico.connect.gateway.sdk.java.domain.payment.CompletePaymentResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.CreatePaymentRequest;
import com.ingenico.connect.gateway.sdk.java.domain.payment.CreatePaymentResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.FindPaymentsResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.PaymentApprovalResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.PaymentErrorResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.PaymentResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.ThirdPartyStatusResponse;
import com.ingenico.connect.gateway.sdk.java.domain.payment.TokenizePaymentRequest;
import com.ingenico.connect.gateway.sdk.java.domain.refund.RefundErrorResponse;
import com.ingenico.connect.gateway.sdk.java.domain.refund.RefundRequest;
import com.ingenico.connect.gateway.sdk.java.domain.refund.RefundResponse;
import com.ingenico.connect.gateway.sdk.java.domain.refund.RefundsResponse;
import com.ingenico.connect.gateway.sdk.java.domain.token.CreateTokenResponse;
/**
* Payments client. Thread-safe.
*/
public class PaymentsClient extends ApiResource {
public PaymentsClient(ApiResource parent, Map pathContext) {
super(parent, pathContext);
}
/**
* Resource /{merchantId}/payments
* - Create payment
*
* @param body CreatePaymentRequest
* @return CreatePaymentResponse
* @throws DeclinedPaymentException if the Ingenico ePayments platform declined / rejected the payment. The payment result will be available from the exception.
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CreatePaymentResponse create(CreatePaymentRequest body) {
return create(body, null);
}
/**
* Resource /{merchantId}/payments
* - Create payment
*
* @param body CreatePaymentRequest
* @param context CallContext
* @return CreatePaymentResponse
* @throws DeclinedPaymentException if the Ingenico ePayments platform declined / rejected the payment. The payment result will be available from the exception.
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CreatePaymentResponse create(CreatePaymentRequest body, CallContext context) {
String uri = instantiateUri("/v1/{merchantId}/payments", null);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
body,
CreatePaymentResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = PaymentErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments
* - Find payments
*
* @param query FindPaymentsParams
* @return FindPaymentsResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public FindPaymentsResponse find(FindPaymentsParams query) {
return find(query, null);
}
/**
* Resource /{merchantId}/payments
* - Find payments
*
* @param query FindPaymentsParams
* @param context CallContext
* @return FindPaymentsResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public FindPaymentsResponse find(FindPaymentsParams query, CallContext context) {
String uri = instantiateUri("/v1/{merchantId}/payments", null);
try {
return communicator.get(
uri,
getClientHeaders(),
query,
FindPaymentsResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}
* - Get payment
*
* @param paymentId String
* @return PaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public PaymentResponse get(String paymentId) {
return get(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}
* - Get payment
*
* @param paymentId String
* @param context CallContext
* @return PaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public PaymentResponse get(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}", pathContext);
try {
return communicator.get(
uri,
getClientHeaders(),
null,
PaymentResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/complete
* - Complete payment
*
* @param paymentId String
* @param body CompletePaymentRequest
* @return CompletePaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CompletePaymentResponse complete(String paymentId, CompletePaymentRequest body) {
return complete(paymentId, body, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/complete
* - Complete payment
*
* @param paymentId String
* @param body CompletePaymentRequest
* @param context CallContext
* @return CompletePaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CompletePaymentResponse complete(String paymentId, CompletePaymentRequest body, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/complete", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
body,
CompletePaymentResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/thirdpartystatus
* - Third party status poll
*
* @param paymentId String
* @return ThirdPartyStatusResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public ThirdPartyStatusResponse thirdPartyStatus(String paymentId) {
return thirdPartyStatus(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/thirdpartystatus
* - Third party status poll
*
* @param paymentId String
* @param context CallContext
* @return ThirdPartyStatusResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public ThirdPartyStatusResponse thirdPartyStatus(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/thirdpartystatus", pathContext);
try {
return communicator.get(
uri,
getClientHeaders(),
null,
ThirdPartyStatusResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/tokenize
* - Create a token from payment
*
* @param paymentId String
* @param body TokenizePaymentRequest
* @return CreateTokenResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CreateTokenResponse tokenize(String paymentId, TokenizePaymentRequest body) {
return tokenize(paymentId, body, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/tokenize
* - Create a token from payment
*
* @param paymentId String
* @param body TokenizePaymentRequest
* @param context CallContext
* @return CreateTokenResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CreateTokenResponse tokenize(String paymentId, TokenizePaymentRequest body, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/tokenize", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
body,
CreateTokenResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/processchallenged
* - Approves challenged payment
*
* @param paymentId String
* @return PaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public PaymentResponse processchallenged(String paymentId) {
return processchallenged(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/processchallenged
* - Approves challenged payment
*
* @param paymentId String
* @param context CallContext
* @return PaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public PaymentResponse processchallenged(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/processchallenged", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
null,
PaymentResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/approve
* - Approve payment
*
* @param paymentId String
* @param body ApprovePaymentRequest
* @return PaymentApprovalResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public PaymentApprovalResponse approve(String paymentId, ApprovePaymentRequest body) {
return approve(paymentId, body, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/approve
* - Approve payment
*
* @param paymentId String
* @param body ApprovePaymentRequest
* @param context CallContext
* @return PaymentApprovalResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public PaymentApprovalResponse approve(String paymentId, ApprovePaymentRequest body, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/approve", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
body,
PaymentApprovalResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/capture
* - Capture payment
*
* @param paymentId String
* @param body CapturePaymentRequest
* @return CaptureResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CaptureResponse capture(String paymentId, CapturePaymentRequest body) {
return capture(paymentId, body, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/capture
* - Capture payment
*
* @param paymentId String
* @param body CapturePaymentRequest
* @param context CallContext
* @return CaptureResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CaptureResponse capture(String paymentId, CapturePaymentRequest body, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/capture", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
body,
CaptureResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/cancelapproval
* - Undo capture payment
*
* @param paymentId String
* @return CancelApprovalPaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CancelApprovalPaymentResponse cancelapproval(String paymentId) {
return cancelapproval(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/cancelapproval
* - Undo capture payment
*
* @param paymentId String
* @param context CallContext
* @return CancelApprovalPaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CancelApprovalPaymentResponse cancelapproval(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/cancelapproval", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
null,
CancelApprovalPaymentResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/captures
* - Get captures of payment
*
* @param paymentId String
* @return CapturesResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CapturesResponse captures(String paymentId) {
return captures(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/captures
* - Get captures of payment
*
* @param paymentId String
* @param context CallContext
* @return CapturesResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CapturesResponse captures(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/captures", pathContext);
try {
return communicator.get(
uri,
getClientHeaders(),
null,
CapturesResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/refund
* - Create refund
*
* @param paymentId String
* @param body RefundRequest
* @return RefundResponse
* @throws DeclinedRefundException if the Ingenico ePayments platform declined / rejected the refund. The refund result will be available from the exception.
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public RefundResponse refund(String paymentId, RefundRequest body) {
return refund(paymentId, body, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/refund
* - Create refund
*
* @param paymentId String
* @param body RefundRequest
* @param context CallContext
* @return RefundResponse
* @throws DeclinedRefundException if the Ingenico ePayments platform declined / rejected the refund. The refund result will be available from the exception.
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public RefundResponse refund(String paymentId, RefundRequest body, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/refund", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
body,
RefundResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = RefundErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/refunds
* - Get refunds of payment
*
* @param paymentId String
* @return RefundsResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public RefundsResponse refunds(String paymentId) {
return refunds(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/refunds
* - Get refunds of payment
*
* @param paymentId String
* @param context CallContext
* @return RefundsResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public RefundsResponse refunds(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/refunds", pathContext);
try {
return communicator.get(
uri,
getClientHeaders(),
null,
RefundsResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/cancel
* - Cancel payment
*
* @param paymentId String
* @return CancelPaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CancelPaymentResponse cancel(String paymentId) {
return cancel(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/cancel
* - Cancel payment
*
* @param paymentId String
* @param context CallContext
* @return CancelPaymentResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public CancelPaymentResponse cancel(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/cancel", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
null,
CancelPaymentResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/dispute
* - Create dispute
*
* @param paymentId String
* @param body CreateDisputeRequest
* @return DisputeResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public DisputeResponse dispute(String paymentId, CreateDisputeRequest body) {
return dispute(paymentId, body, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/dispute
* - Create dispute
*
* @param paymentId String
* @param body CreateDisputeRequest
* @param context CallContext
* @return DisputeResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public DisputeResponse dispute(String paymentId, CreateDisputeRequest body, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/dispute", pathContext);
try {
return communicator.post(
uri,
getClientHeaders(),
null,
body,
DisputeResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
/**
* Resource /{merchantId}/payments/{paymentId}/disputes
* - Get disputes
*
* @param paymentId String
* @return DisputesResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public DisputesResponse disputes(String paymentId) {
return disputes(paymentId, null);
}
/**
* Resource /{merchantId}/payments/{paymentId}/disputes
* - Get disputes
*
* @param paymentId String
* @param context CallContext
* @return DisputesResponse
* @throws ValidationException if the request was not correct and couldn't be processed (HTTP status code 400)
* @throws AuthorizationException if the request was not allowed (HTTP status code 403)
* @throws IdempotenceException if an idempotent request caused a conflict (HTTP status code 409)
* @throws ReferenceException if an object was attempted to be referenced that doesn't exist or has been removed,
* or there was a conflict (HTTP status code 404, 409 or 410)
* @throws GlobalCollectException if something went wrong at the Ingenico ePayments platform,
* the Ingenico ePayments platform was unable to process a message from a downstream partner/acquirer,
* or the service that you're trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)
* @throws ApiException if the Ingenico ePayments platform returned any other error
*/
public DisputesResponse disputes(String paymentId, CallContext context) {
Map pathContext = new TreeMap();
pathContext.put("paymentId", paymentId);
String uri = instantiateUri("/v1/{merchantId}/payments/{paymentId}/disputes", pathContext);
try {
return communicator.get(
uri,
getClientHeaders(),
null,
DisputesResponse.class,
context);
} catch (ResponseException e) {
final Class errorType = ErrorResponse.class;
final Object errorObject = communicator.getMarshaller().unmarshal(e.getBody(), errorType);
throw createException(e.getStatusCode(), e.getBody(), errorObject, context);
}
}
}