public function capture(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
$order_num = $payment->getOrder()->getIncrementId();
try {
$monetra = new MonetraInterface($this->getMonetraConfigData());
$ttid = $payment->getParentTransactionId();
if (!empty($ttid)) {
$response = $monetra->capture($ttid, $order_num);
} else {
if (!$this->hmacIsValid()) {
$this->_logger->error('HMAC SHA-256 from Monetra client ticket request failed verification.');
throw new LocalizedException(__('Verification of payment information failed.'));
}
$ticket = $this->getInfoInstance()->getAdditionalInformation('ticket');
$response = $monetra->sale($ticket, $amount, $order_num);
}
} catch (MonetraException $e) {
$this->_logger->critical("Error occurred while attempting Monetra capture. Details: " . $e->getMessage());
throw new LocalizedException(__($this->_scopeConfig->getValue('payment/monetra_client_ticket/user_facing_error_message')));
}
if ($response['code'] !== 'AUTH') {
$this->_logger->info(sprintf('Monetra capture failed for TTID %d. Verbiage: %s', $response['ttid'], $response['verbiage']));
throw new LocalizedException(__($this->_scopeConfig->getValue('payment/monetra_client_ticket/user_facing_deny_message')));
}
return $this;
}
/**
* Creates Payment Data Object
*
* @param InfoInterface $paymentInfo
* @return PaymentDataObjectInterface
*/
public function create(InfoInterface $paymentInfo)
{
if ($paymentInfo instanceof Payment) {
$data['order'] = $this->orderAdapterFactory->create(['order' => $paymentInfo->getOrder()]);
} elseif ($paymentInfo instanceof \Magento\Quote\Model\Quote\Payment) {
$data['order'] = $this->quoteAdapterFactory->create(['quote' => $paymentInfo->getQuote()]);
}
$data['payment'] = $paymentInfo;
return $this->objectManager->create('Magento\\Payment\\Gateway\\Data\\PaymentDataObject', $data);
}
/**
* Payment capturing
*
* @param \Magento\Payment\Model\InfoInterface $payment
* @param float $amount
* @return $this
* @throws \Magento\Framework\Validator\Exception
*/
public function capture(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
//throw new \Magento\Framework\Validator\Exception(__('Inside Stripe, throwing donuts :]'));
/** @var \Magento\Sales\Model\Order $order */
$order = $payment->getOrder();
/** @var \Magento\Sales\Model\Order\Address $billing */
$billing = $order->getBillingAddress();
try {
$requestData = ['amount' => $amount * 100, 'currency' => strtolower($order->getBaseCurrencyCode()), 'description' => sprintf('#%s, %s', $order->getIncrementId(), $order->getCustomerEmail()), 'card' => ['number' => $payment->getCcNumber(), 'exp_month' => sprintf('%02d', $payment->getCcExpMonth()), 'exp_year' => $payment->getCcExpYear(), 'cvc' => $payment->getCcCid(), 'name' => $billing->getName(), 'address_line1' => $billing->getStreetLine(1), 'address_line2' => $billing->getStreetLine(2), 'address_city' => $billing->getCity(), 'address_zip' => $billing->getPostcode(), 'address_state' => $billing->getRegion(), 'address_country' => $billing->getCountryId()]];
$charge = \Stripe\Charge::create($requestData);
$payment->setTransactionId($charge->id)->setIsTransactionClosed(0);
} catch (\Exception $e) {
$this->debugData(['request' => $requestData, 'exception' => $e->getMessage()]);
$this->_logger->error(__('Payment capturing error.'));
throw new \Magento\Framework\Validator\Exception(__('Payment capturing error.'));
}
return $this;
}
/**
* Performs authorize transaction
*
* @param \Magento\Payment\Model\InfoInterface|Object $payment
* @param float $amount
* @return $this
* @throws InvalidTransitionException
* @throws LocalizedException
*/
public function authorize(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
$request = $this->buildBasicRequest();
$order = $payment->getOrder();
$this->addRequestOrderInfo($request, $order);
$request = $this->fillCustomerContacts($order, $request);
$request->setTrxtype(self::TRXTYPE_AUTH_ONLY);
$request->setOrigid($payment->getAdditionalInformation('pnref'));
$request->setAmt(round($amount, 2));
$response = $this->postRequest($request, $this->getConfig());
$this->processErrors($response);
try {
$this->responseValidator->validate($response);
} catch (LocalizedException $exception) {
$payment->setParentTransactionId($response->getPnref());
$this->void($payment);
throw new LocalizedException(__('Error processing payment, please try again later.'));
}
$this->setTransStatus($payment, $response);
$payment->unsAdditionalInformation('pnref');
return $this;
}
/**
* @param \Magento\Payment\Model\InfoInterface $payment
* @param float $amount
* @return $this
* @throws LocalizedException
*/
public function refund(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
$senderCustomer = $payment->getAdditionalInformation('destination_customer');
$customerId = $payment->getOrder()->getCustomerId();
$customer = $this->customerRepository->getById($customerId);
$destinationCustomer = $customer->getCustomAttribute('openpay_customer_id')->getValue();
$paymentLeyend = __('Refund for: ') . __($this->getConfigData('paymentLeyend'))->getText();
$order = $payment->getOrder();
$useOrderId = $this->getConfigData('useOrderId');
$orderId = $order->getIncrementId();
$params = ['customer_id' => $destinationCustomer, 'amount' => $amount, 'description' => $paymentLeyend, 'order_id' => $useOrderId ? $orderId . '-refund' : null];
try {
$transaction = $this->transferAdapter->transfer($senderCustomer, $params);
$payment->setTransactionId($transaction->getId())->setIsTransactionClosed(0);
$this->openpayCustomerRepository->clearCustomerCache($senderCustomer);
$this->openpayCustomerRepository->clearCustomerCache($destinationCustomer);
} catch (OpenpayException $e) {
$this->debugData(['request' => $params, 'exception' => $e->getMessage()]);
$this->_logger->error(__('Payment capturing error.'));
throw new LocalizedException(__('[' . $e->getErrorCode() . ']' . $e->getMessage()));
}
return parent::refund($payment, $amount);
// TODO: Change the autogenerated stub
}
public function authorize(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
if (!$this->canAuthorize()) {
throw new \Magento\Framework\Exception\LocalizedException(__('The authorize action is not available.'));
}
$payment->getAdditionalInformation();
$order = $payment->getOrder();
$billing_address = $order->getBillingAddress();
$shipping_address = $order->getShippingAddress();
$params = array();
$params["sellerId"] = $this->getConfigData("merchant_id");
$params["privateKey"] = $this->getConfigData("private_key");
$params["merchantOrderId"] = $order->getRealOrderId();
$params["currency"] = $order->getOrderCurrencyCode();
$params["token"] = $payment->getAdditionalInformation()['token'];
$params["total"] = round($order->getGrandTotal(), 2);
// Set billing info
$params["billingAddr"] = array();
$params["billingAddr"]["name"] = $billing_address->getName();
$params["billingAddr"]["addrLine1"] = $billing_address->getStreet()[0];
if (count($billing_address->getStreet()) > 1) {
$params["billingAddr"]["addrLine2"] = $billing_address->getStreet()[1];
}
$params["billingAddr"]["city"] = $billing_address->getCity();
$params["billingAddr"]["state"] = $billing_address->getRegion();
$params["billingAddr"]["zipCode"] = $billing_address->getPostcode();
$params["billingAddr"]["country"] = $billing_address->getCountryId();
$params["billingAddr"]["email"] = $order->getCustomerEmail();
$params["billingAddr"]["phoneNumber"] = $billing_address->getTelephone();
if (isset($shipping_address)) {
$params["shippingAddress"] = array();
$params["shippingAddress"]["name"] = $shipping_address->getName();
$params["shippingAddress"]["addrLine1"] = $shipping_address->getStreet()[0];
if (count($shipping_address->getStreet()) > 1) {
$params["shippingAddress"]["addrLine2"] = $shipping_address->getStreet()[1];
}
$params["shippingAddress"]["city"] = $shipping_address->getCity();
$params["shippingAddress"]["state"] = $shipping_address->getRegion();
$params["shippingAddress"]["zipCode"] = $shipping_address->getPostcode();
$params["shippingAddress"]["country"] = $shipping_address->getCountryId();
}
$client = $this->_httpClientFactory->create();
$path = $this->getConfigData('merchant_id') . "/rs/authService";
$url = $this->getPaymentApiUrl();
$client->setUri($url . $path);
$client->setConfig(['maxredirects' => 0, 'timeout' => 30]);
$client->setHeaders(['Accept: application/json', 'Content-Type: application/json']);
$client->setMethod(\Zend_Http_Client::POST);
$client->setRawData(json_encode($params), 'application/json');
try {
$response = $client->request();
$responseBody = json_decode($response->getBody(), true);
if (isset($responseBody['exception'])) {
throw new \Magento\Framework\Exception\LocalizedException(__($responseBody['exception']['errorMsg']));
} elseif (!isset($responseBody['response'])) {
throw new \Magento\Framework\Exception\LocalizedException(__('Error placing transaction.'));
}
} catch (\Exception $e) {
throw new \Magento\Framework\Exception\LocalizedException(__($e->getMessage()));
}
$payment->setTransactionId($responseBody['response']['transactionId']);
$payment->setIsTransactionClosed(0);
$payment->setTransactionAdditionalInfo('tco_order_number', $responseBody['response']['orderNumber']);
$payment->setAdditionalInformation('tco_order_number', $responseBody['response']['orderNumber']);
$payment->setAdditionalInformation('tco_order_status', 'approved');
return $this;
}
/**
* Capture payment
*
* @param \Magento\Framework\DataObject|\Magento\Payment\Model\InfoInterface|Payment $payment
* @param float $amount
* @return $this
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
* @SuppressWarnings(PHPMD.NPathComplexity)
*/
public function capture(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
$authorizationTransaction = $payment->getAuthorizationTransaction();
$authorizationPeriod = abs(intval($this->getConfigData('authorization_honor_period')));
$maxAuthorizationNumber = abs(intval($this->getConfigData('child_authorization_number')));
$order = $payment->getOrder();
$isAuthorizationCreated = false;
if ($payment->getAdditionalInformation($this->_isOrderPaymentActionKey)) {
$voided = false;
if (!$authorizationTransaction->getIsClosed() && $this->_isTransactionExpired($authorizationTransaction, $authorizationPeriod)) {
//Save payment state and configure payment object for voiding
$isCaptureFinal = $payment->getShouldCloseParentTransaction();
$payment->setShouldCloseParentTransaction(false);
$payment->setParentTransactionId($authorizationTransaction->getTxnId());
$payment->unsTransactionId();
$payment->setVoidOnlyAuthorization(true);
$payment->void(new \Magento\Framework\DataObject());
//Revert payment state after voiding
$payment->unsAuthorizationTransaction();
$payment->unsTransactionId();
$payment->setShouldCloseParentTransaction($isCaptureFinal);
$voided = true;
}
if ($authorizationTransaction->getIsClosed() || $voided) {
if ($payment->getAdditionalInformation($this->_authorizationCountKey) > $maxAuthorizationNumber - 1) {
$this->_exception->create(['phrase' => __('The maximum number of child authorizations is reached.')]);
}
$api = $this->_callDoAuthorize($amount, $payment, $authorizationTransaction->getParentTxnId());
//Adding authorization transaction
$this->_pro->importPaymentInfo($api, $payment);
$payment->setTransactionId($api->getTransactionId());
$payment->setParentTransactionId($authorizationTransaction->getParentTxnId());
$payment->setIsTransactionClosed(false);
$formatedPrice = $order->getBaseCurrency()->formatTxt($amount);
if ($payment->getIsTransactionPending()) {
$message = __('We\'ll authorize the amount of %1 as soon as the payment gateway approves it.', $formatedPrice);
} else {
$message = __('The authorized amount is %1.', $formatedPrice);
}
$transaction = $this->transactionBuilder->setPayment($payment)->setOrder($order)->setTransactionId($payment->getTransactionId())->setFailSafe(true)->build(Transaction::TYPE_AUTH);
$payment->addTransactionCommentsToOrder($transaction, $message);
$payment->setParentTransactionId($api->getTransactionId());
$isAuthorizationCreated = true;
}
//close order transaction if needed
if ($payment->getShouldCloseParentTransaction()) {
$orderTransaction = $this->getOrderTransaction($payment);
if ($orderTransaction) {
$orderTransaction->setIsClosed(true);
$order->addRelatedObject($orderTransaction);
}
}
}
if (false === $this->_pro->capture($payment, $amount)) {
$this->_placeOrder($payment, $amount);
}
if ($isAuthorizationCreated && isset($transaction)) {
$transaction->setIsClosed(true);
}
return $this;
}
/**
* Update Order Status
*
* Used by the Direct Payment method
*
* @param \Magento\Payment\Model\InfoInterface $payment
*/
protected function updateOrderStatus(\Magento\Payment\Model\InfoInterface $payment)
{
$additionalInfo = $payment->getTransactionAdditionalInfo();
$rawDetails = \Magento\Sales\Model\Order\Payment\Transaction::RAW_DETAILS;
if (array_key_exists($rawDetails, $additionalInfo) && array_key_exists('status', $additionalInfo[$rawDetails])) {
$status = $additionalInfo[$rawDetails]['status'];
$order = $payment->getOrder();
/*
$configHelper = $this->getModuleHelper()->getMethodConfig(
$payment->getMethod()
);
*/
switch ($status) {
case \Genesis\API\Constants\Transaction\States::PENDING_ASYNC:
// Redirecting to the 3D secure URL
if (array_key_exists('redirect_url', $additionalInfo[$rawDetails]) && !empty($additionalInfo[$rawDetails]['redirect_url'])) {
$this->getModuleHelper()->setOrderState($order, \Genesis\API\Constants\Transaction\States::PENDING_ASYNC);
}
break;
case \Genesis\API\Constants\Transaction\States::APPROVED:
if (array_key_exists($rawDetails, $additionalInfo) && array_key_exists('transaction_type', $additionalInfo[$rawDetails])) {
$transactionType = $additionalInfo[$rawDetails]['transaction_type'];
}
$this->getModuleHelper()->setOrderStatusByState($order, $transactionType == \Genesis\API\Constants\Transaction\Types::SALE ? \Magento\Sales\Model\Order::STATE_COMPLETE : \Magento\Sales\Model\Order::STATE_PROCESSING);
break;
default:
// Other status. Do nothing.
}
}
}
/**
* Attempt to void the authorization on cancelling
*
* @param InfoInterface|Object $payment
* @return $this
*/
public function cancel(\Magento\Payment\Model\InfoInterface $payment)
{
if (!$payment->getOrder()->getInvoiceCollection()->count()) {
return $this->void($payment);
}
return false;
}
/**
* @param \Magento\Payment\Model\InfoInterface $payment
* @param float $amount
* @return $this
*/
public function refund(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
/**
* @var $order \Magento\Sales\Model\Order
*/
$order = $payment->getOrder();
$payuplOrderId = $this->transactionResource->getLastPayuplOrderIdByOrderId($order->getId());
$client = $this->clientFactory->create();
$client->refundCreate($payuplOrderId, __('Refund for order # %1', $order->getIncrementId()), $amount * 100);
return $this;
}
/**
* Performs authorize transaction
*
* @param InfoInterface|Object $payment
* @param float $amount
* @return $this
* @throws InvalidTransitionException
* @throws LocalizedException
*/
public function authorize(InfoInterface $payment, $amount)
{
/** @var Payment $payment */
$request = $this->buildBasicRequest();
/** @var \Magento\Sales\Model\Order $order */
$order = $payment->getOrder();
$this->addRequestOrderInfo($request, $order);
$request = $this->fillCustomerContacts($order, $request);
$token = $payment->getAdditionalInformation(self::PNREF);
$request->setData('trxtype', self::TRXTYPE_AUTH_ONLY);
$request->setData('origid', $token);
$request->setData('amt', $this->formatPrice($amount));
$response = $this->postRequest($request, $this->getConfig());
$this->processErrors($response);
try {
$this->responseValidator->validate($response, $this);
} catch (LocalizedException $exception) {
$payment->setParentTransactionId($response->getData(self::PNREF));
$this->void($payment);
throw new LocalizedException(__('Error processing payment. Please try again later.'));
}
$this->setTransStatus($payment, $response);
$this->createPaymentToken($payment, $token);
$payment->unsAdditionalInformation(self::CC_DETAILS);
return $this;
}
/**
* Fetch transaction details info
*
* Update transaction info if there is one placing transaction only
*
* @param \Magento\Payment\Model\InfoInterface $payment
* @param string $transactionId
* @return array
*/
public function fetchTransactionInfo(\Magento\Payment\Model\InfoInterface $payment, $transactionId)
{
$transaction = $this->transactionRepository->getByTransactionId($transactionId, $payment->getId(), $payment->getOrder()->getId());
$response = $this->getTransactionResponse($transactionId);
if ($response->getXResponseCode() == self::RESPONSE_CODE_APPROVED) {
if ($response->getTransactionStatus() == 'voided') {
$payment->setIsTransactionDenied(true);
$payment->setIsTransactionClosed(true);
$transaction->close();
} else {
$transaction->setAdditionalInformation(self::TRANSACTION_FRAUD_STATE_KEY, false);
$payment->setIsTransactionApproved(true);
}
} elseif ($response->getXResponseReasonCode() == self::RESPONSE_REASON_CODE_PENDING_REVIEW_DECLINED) {
$payment->setIsTransactionDenied(true);
}
$this->addStatusCommentOnUpdate($payment, $response, $transactionId);
return [];
}
/**
* Format price with currency sign
* @param \Magento\Payment\Model\InfoInterface $payment
* @param float $amount
* @return string
*/
protected function formatPrice($payment, $amount)
{
return $payment->getOrder()->getBaseCurrency()->formatTxt($amount);
}
public function authorize(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
if (!$this->canAuthorize()) {
throw new \Magento\Framework\Exception\LocalizedException(__('The authorize action is not available.'));
}
/*
* do not send order confirmation mail after order creation wait for
* Adyen AUTHORIISATION notification
*/
$order = $payment->getOrder();
$order->setCanSendNewEmailFlag(false);
// do not let magento set status to processing
$payment->setLastTransId($this->getTransactionId())->setIsTransactionPending(true);
// DO authorisation
$this->_processRequest($payment, $amount, "authorise");
return $this;
}
/**
* Send authorize request to gateway
*
* @param \Magento\Framework\DataObject|\Magento\Payment\Model\InfoInterface $payment
* @param float $amount
* @return void
* @SuppressWarnings(PHPMD.UnusedFormalParameter)
*/
public function authorize(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
$this->_logger->addDebug('Directpost authorize was hit');
$payment->setAdditionalInformation('is_transaction_pending', 1);
$order = $payment->getOrder();
$order->setState('pending');
$order->setStatus('pending');
}
/**
* Returns request object with needed data for API request to PayPal to get form URL.
*
* @param \Magento\Payment\Model\InfoInterface $payment
* @return \Magento\Paypal\Model\Hostedpro\Request
*/
protected function _buildFormUrlRequest(\Magento\Payment\Model\InfoInterface $payment)
{
$order = $payment->getOrder();
$request = $this->_buildBasicRequest()->setOrder($order)->setPaymentMethod($this)->setAmount($order);
return $request;
}
/**
* Processes reference transactions
* - Capture
* - Refund
* - Void
*
* @param \Magento\Payment\Model\InfoInterface $payment
* @param $amount
* @throws \Exception
*/
protected function processRefTransaction(\Magento\Payment\Model\InfoInterface $payment, $amount)
{
$transactionType = $this->getTransactionType();
$order = $payment->getOrder();
switch ($transactionType) {
case \Genesis\API\Constants\Transaction\Types::CAPTURE:
$data = array('transaction_id' => $this->getModuleHelper()->genTransactionId(), 'remote_ip' => $order->getRemoteIp(), 'reference_id' => $this->getReferenceCaptureTxnId($payment), 'currency' => $order->getBaseCurrencyCode(), 'amount' => $amount);
break;
case \Genesis\API\Constants\Transaction\Types::REFUND:
$data = array('transaction_id' => $this->getModuleHelper()->genTransactionId(), 'remote_ip' => $order->getRemoteIp(), 'reference_id' => $this->getReferenceRefundTxnId($payment), 'currency' => $order->getBaseCurrencyCode(), 'amount' => $amount);
break;
case \Genesis\API\Constants\Transaction\Types::VOID:
$data = array('transaction_id' => $this->getModuleHelper()->genTransactionId(), 'remote_ip' => $order->getRemoteIp(), 'reference_id' => $this->getReferenceVoidTxnId($payment));
break;
default:
throw new \Exception(__('Unsupported transaction (' . $transactionType . ').'));
}
$responseObject = $this->processReferenceTransaction($transactionType, $payment, $data);
if ($responseObject->status == \Genesis\API\Constants\Transaction\States::APPROVED) {
$this->getMessageManager()->addSuccess($responseObject->message);
} else {
throw new \Exception(__($responseObject->message));
}
}
/**
* @param InfoInterface $payment
* @return array
*/
protected function getTransactionsToVoid(InfoInterface $payment)
{
$transactionIds = [];
$invoice = $this->_registry->registry('current_invoice');
if ($invoice && $invoice->getId() && $invoice->getTransactionId()) {
$transactionIds[] = $this->braintreeHelper->clearTransactionId($invoice->getTransactionId());
} else {
$collection = $this->salesTransactionCollectionFactory->create()->addFieldToSelect('txn_id')->addOrderIdFilter($payment->getOrder()->getId())->addTxnTypeFilter([PaymentTransaction::TYPE_AUTH, PaymentTransaction::TYPE_CAPTURE]);
$fetchedIds = $collection->getColumnValues('txn_id');
foreach ($fetchedIds as $transactionId) {
$txnId = $this->braintreeHelper->clearTransactionId($transactionId);
if (!in_array($txnId, $transactionIds)) {
$transactionIds[] = $txnId;
}
}
}
return $transactionIds;
}
/**
* Void Payment
* @param \Magento\Payment\Model\InfoInterface $payment
* @return $this
* @throws \Magento\Framework\Webapi\Exception
*/
public function void(\Magento\Payment\Model\InfoInterface $payment)
{
/** @var \Magento\Sales\Model\Order $order */
$order = $payment->getOrder();
$this->getLogger()->debug('Void transaction for order #' . $order->getIncrementId());
$referenceTransaction = $this->getModuleHelper()->lookUpVoidReferenceTransaction($payment);
if ($referenceTransaction->getTxnType() == \Magento\Sales\Model\Order\Payment\Transaction::TYPE_AUTH) {
$authTransaction = $referenceTransaction;
} else {
$authTransaction = $this->getModuleHelper()->lookUpAuthorizationTransaction($payment);
}
if (!isset($authTransaction) || !isset($referenceTransaction)) {
$errorMessage = 'Void transaction for order #' . $order->getIncrementId() . ' cannot be finished (No Authorize / Capture Transaction exists)';
$this->getLogger()->error($errorMessage);
$this->getModuleHelper()->throwWebApiException($errorMessage);
}
try {
$this->getModuleHelper()->setTokenByPaymentTransaction($authTransaction);
$data = array('transaction_id' => $this->getModuleHelper()->genTransactionId(), 'remote_ip' => $order->getRemoteIp(), 'reference_id' => $referenceTransaction->getTxnId());
$responseObject = $this->processReferenceTransaction(\Genesis\API\Constants\Transaction\Types::VOID, $payment, $data);
if ($responseObject->status == \Genesis\API\Constants\Transaction\States::APPROVED) {
$this->getMessageManager()->addSuccess($responseObject->message);
} else {
$this->getModuleHelper()->throwWebApiException($responseObject->message);
}
unset($data);
} catch (\Exception $e) {
$this->getLogger()->error($e->getMessage());
$this->getModuleHelper()->maskException($e);
}
return $this;
}
/**
* Void payment
* Void is in regards to the payment on the order invoice - to void the authorization, for instance - so that
* the funds aren't subsequently captured. Payments have to be refunded after capture and cannot be voided.
*
* map this operation to APPROVEREVERSAL
*
* @param \Magento\Framework\DataObject|InfoInterface|\Magento\Sales\Model\Order\Payment $payment
*
* @return $this
* @throws \Exception
* @api
* @SuppressWarnings(PHPMD.UnusedFormalParameter)
*/
public function void(\Magento\Payment\Model\InfoInterface $payment)
{
if (!$this->_dataHelper->isBackendAvailable()) {
return $this;
}
$orderNumber = $payment->getAdditionalInformation('orderNumber');
if (!strlen($orderNumber)) {
/* dont throw an exception here, might be a pending payment */
$this->_logger->debug(__METHOD__ . ':No order number found.');
return $this;
}
$orderDetails = $this->getOrderDetails($orderNumber);
$backendClient = $this->_dataHelper->getBackendClient();
$approveDone = false;
foreach ($orderDetails->getOrder()->getPayments() as $wdPayment) {
/** @var \WirecardCEE_QPay_Response_Toolkit_Order_Payment $wdPayment */
$this->_logger->debug(__METHOD__ . ':operations allowed:' . implode(',', $wdPayment->getOperationsAllowed()));
if (in_array('APPROVEREVERSAL', $wdPayment->getOperationsAllowed())) {
$this->_logger->debug(__METHOD__ . ":{$orderNumber}");
$ret = $backendClient->approveReversal($orderNumber);
if ($ret->hasFailed()) {
throw new \Exception($ret->getError()->getMessage());
}
$approveDone = true;
$orderTransaction = $this->_transactionRepository->getByTransactionType(Transaction::TYPE_ORDER, $payment->getId(), $payment->getOrder()->getId());
if ($orderTransaction) {
$payment->setParentTransactionId($orderTransaction->getTxnId());
$payment->setTransactionId($orderTransaction->getTxnId() . '-void');
}
$payment->addTransactionCommentsToOrder($orderTransaction, 'approveReversal');
}
}
if (!$approveDone) {
throw new \Exception($this->_dataHelper->__('Void not possible anymore for this payment, please try cancel instead!'));
}
return $this;
}
