PHP Exception\RequestNotSupportedException类代码示例

 /**
  * {@inheritdoc}
  *
  * @param $request Capture
  */
 public function execute($request)
 {
     RequestNotSupportedException::assertSupports($this, $request);
     /** @var $payment SyliusPaymentInterface */
     $payment = $request->getModel();
     /** @var OrderInterface $order */
     $order = $payment->getOrder();
     $this->gateway->execute($status = new GetStatus($payment));
     if ($status->isNew()) {
         try {
             $this->gateway->execute($convert = new Convert($payment, 'array', $request->getToken()));
             $payment->setDetails($convert->getResult());
         } catch (RequestNotSupportedException $e) {
             $totalAmount = $order->getTotal();
             $payumPayment = new PayumPayment();
             $payumPayment->setNumber($order->getNumber());
             $payumPayment->setTotalAmount($totalAmount);
             $payumPayment->setCurrencyCode($order->getCurrencyCode());
             $payumPayment->setClientEmail($order->getCustomer()->getEmail());
             $payumPayment->setClientId($order->getCustomer()->getId());
             $payumPayment->setDescription(sprintf('Payment contains %d items for a total of %01.2f', $order->getItems()->count(), round($totalAmount / 100, 2)));
             $payumPayment->setDetails($payment->getDetails());
             $this->gateway->execute($convert = new Convert($payumPayment, 'array', $request->getToken()));
             $payment->setDetails($convert->getResult());
         }
     }
     $details = ArrayObject::ensureArrayObject($payment->getDetails());
     try {
         $request->setModel($details);
         $this->gateway->execute($request);
     } finally {
         $payment->setDetails((array) $details);
     }
 }

 /**
  * {@inheritDoc}
  */
 public function execute($request)
 {
     /** @var $request StatusRequestInterface */
     if (false == $this->supports($request)) {
         throw RequestNotSupportedException::createActionNotSupported($this, $request);
     }
     /** @var PaymentInterface $payment */
     $payment = $request->getModel();
     if (in_array($payment->getState(), array(PaymentInterface::STATE_APPROVED, PaymentInterface::STATE_DEPOSITED))) {
         $request->markSuccess();
         return;
     }
     if (in_array($payment->getState(), array(PaymentInterface::STATE_DEPOSITING))) {
         $request->markPending();
         return;
     }
     if (in_array($payment->getState(), array(PaymentInterface::STATE_CANCELED))) {
         $request->markCanceled();
         return;
     }
     if (in_array($payment->getState(), array(PaymentInterface::STATE_EXPIRED))) {
         $request->markExpired();
         return;
     }
     if (in_array($payment->getState(), array(PaymentInterface::STATE_FAILED))) {
         $request->markFailed();
         return;
     }
     if (in_array($payment->getState(), array(PaymentInterface::STATE_NEW, PaymentInterface::STATE_APPROVING))) {
         $request->markNew();
         return;
     }
     $request->markUnknown();
 }

 /**
  * {@inheritDoc}
  */
 public function execute($request)
 {
     if (!$this->supports($request)) {
         throw RequestNotSupportedException::createActionNotSupported($this, $request);
     }
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if ($model['_status']) {
         return;
     }
     if (false == $model->validateNotEmpty(array('card'), false)) {
         try {
             $creditCardRequest = new ObtainCreditCardRequest();
             $this->payment->execute($creditCardRequest);
             $card = $creditCardRequest->obtain();
             $firstName = $lastName = '';
             list($firstName, $lastName) = explode(' ', $card->getHolder(), 1);
             $model['card'] = new SensitiveValue(array('number' => $card->getNumber(), 'cvv' => $card->getSecurityCode(), 'expiryMonth' => $card->getExpireAt()->format('m'), 'expiryYear' => $card->getExpireAt()->format('y'), 'firstName' => $firstName, 'lastName' => $lastName));
         } catch (RequestNotSupportedException $e) {
             throw new LogicException('Credit card details has to be set explicitly or there has to be an action that supports ObtainCreditCardRequest request.');
         }
     }
     $response = $this->gateway->purchase($model->toUnsafeArray())->send();
     $model['_reference'] = $response->getTransactionReference();
     $model['_status'] = $response->isSuccessful() ? 'success' : 'failed';
     $model['_status_code'] = $response->getCode();
     $model['_status_message'] = $response->isSuccessful() ? '' : $response->getMessage();
 }

 /**
  * {@inheritdoc}
  */
 public function execute($request)
 {
     RequestNotSupportedException::assertSupports($this, $request);
     /** @var GetStatusInterface $request */
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if (false == $model['transaction_id']) {
         $request->markNew();
         return;
     }
     if (false != ($responseCode = $model['response_code'])) {
         // Success
         if ('00' === $responseCode) {
             $request->markCaptured();
             return;
         }
         // Cancelled by user
         if ('17' === $responseCode) {
             $request->markCanceled();
             return;
         }
         // Failure
         $request->markFailed();
         return;
     }
     $request->markPending();
 }

 /**
  * {@inheritDoc}
  *
  * @param GetStatusInterface $request
  */
 public function execute($request)
 {
     RequestNotSupportedException::assertSupports($this, $request);
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if ($model['error_code']) {
         $request->markFailed();
         return;
     }
     if ($model['invoice_number']) {
         $request->markCaptured();
         return;
     }
     if ($model['reservation']) {
         $request->markAuthorized();
         return;
     }
     if (false == $model['status'] || Constants::STATUS_CHECKOUT_INCOMPLETE == $model['status']) {
         $request->markNew();
         return;
     }
     if (Constants::STATUS_CHECKOUT_COMPLETE == $model['status']) {
         $request->markPending();
         return;
     }
     $request->markUnknown();
 }

 /**
  * {@inheritdoc}
  */
 public function execute($request)
 {
     /**
      * @var $request \Payum\Core\Request\CaptureRequest
      */
     if (false == $this->supports($request)) {
         throw RequestNotSupportedException::createActionNotSupported($this, $request);
     }
     /** @var Payment $model */
     $model = $request->getModel();
     if (false == isset($model->state) && isset($model->payer->payment_method) && 'paypal' == $model->payer->payment_method) {
         $model->create($this->api);
         foreach ($model->links as $link) {
             if ($link->rel == 'approval_url') {
                 throw new RedirectUrlInteractiveRequest($link->href);
             }
         }
     }
     if (false == isset($model->state) && isset($model->payer->payment_method) && 'credit_card' == $model->payer->payment_method) {
         $model->create($this->api);
     }
     if (true == isset($model->state) && isset($model->payer->payment_method) && 'paypal' == $model->payer->payment_method) {
         $execution = new PaymentExecution();
         $execution->payer_id = $_GET['PayerID'];
         //Execute the payment
         $model->execute($execution, $this->api);
     }
 }

 /**
  * {@inheritDoc}
  */
 public function execute($request)
 {
     /** @var $request Capture */
     if (false == $this->supports($request)) {
         throw RequestNotSupportedException::createActionNotSupported($this, $request);
     }
     $model = new ArrayObject($request->getModel());
     if (is_numeric($model['RESULT'])) {
         return;
     }
     $cardFields = array('ACCT', 'CVV2', 'EXPDATE');
     if (false == $model->validateNotEmpty($cardFields, false)) {
         try {
             $this->payment->execute($obtainCreditCard = new ObtainCreditCard());
             $card = $obtainCreditCard->obtain();
             $model['EXPDATE'] = new SensitiveValue($card->getExpireAt()->format('my'));
             $model['ACCT'] = $card->getNumber();
             $model['CVV2'] = $card->getSecurityCode();
         } catch (RequestNotSupportedException $e) {
             throw new LogicException('Credit card details has to be set explicitly or there has to be an action that supports ObtainCreditCard request.');
         }
     }
     $buzzRequest = new Request();
     $buzzRequest->setFields($model->toUnsafeArray());
     $response = $this->api->doPayment($buzzRequest);
     $model->replace($response);
 }

 /**
  * {@inheritDoc}
  *
  * @param Notify $request
  */
 public function execute($request)
 {
     RequestNotSupportedException::assertSupports($this, $request);
     $details = ArrayObject::ensureArrayObject($request->getModel());
     $this->gateway->execute($httpRequest = new GetHttpRequest());
     if (!isset($httpRequest->request['merchantReference']) || empty($httpRequest->request['merchantReference'])) {
         $details['response_status'] = 401;
         return;
     }
     if (!isset($details['merchantReference']) || $details['merchantReference'] != $httpRequest->request['merchantReference']) {
         $details['response_status'] = 402;
         return;
     }
     if (false === $this->api->verifyNotification($httpRequest->request)) {
         $details['response_status'] = 403;
         return;
     }
     // Check notification code
     if (isset($httpRequest->request['eventCode'])) {
         $httpRequest->request['authResult'] = $httpRequest->request['eventCode'];
         if ('AUTHORISATION' == $httpRequest->request['eventCode']) {
             if ('true' == $httpRequest->request['success']) {
                 $httpRequest->request['authResult'] = 'AUTHORISED';
             } elseif (!empty($httpRequest->request['reason'])) {
                 $httpRequest->request['authResult'] = 'REFUSED';
             }
         }
     }
     $details['authResult'] = $httpRequest->request['authResult'];
     $details['response_status'] = 200;
 }

 /**
  * {@inheritdoc}
  */
 public function execute($request)
 {
     /** @var $request CaptureRequest */
     if (false == $this->supports($request)) {
         throw RequestNotSupportedException::createActionNotSupported($this, $request);
     }
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if (false == $model['PAYMENTREQUEST_0_PAYMENTACTION']) {
         $model['PAYMENTREQUEST_0_PAYMENTACTION'] = Api::PAYMENTACTION_SALE;
     }
     if (false == $model['TOKEN']) {
         if (false == $model['RETURNURL'] && $request instanceof SecuredCaptureRequest) {
             $model['RETURNURL'] = $request->getToken()->getTargetUrl();
         }
         if (false == $model['CANCELURL'] && $request instanceof SecuredCaptureRequest) {
             $model['CANCELURL'] = $request->getToken()->getTargetUrl();
         }
         $this->payment->execute(new SetExpressCheckoutRequest($model));
         $this->payment->execute(new AuthorizeTokenRequest($model));
     }
     $this->payment->execute(new SyncRequest($model));
     if ($model['PAYERID'] && Api::CHECKOUTSTATUS_PAYMENT_ACTION_NOT_INITIATED == $model['CHECKOUTSTATUS'] && $model['PAYMENTREQUEST_0_AMT'] > 0) {
         $this->payment->execute(new DoExpressCheckoutPaymentRequest($model));
     }
     $this->payment->execute(new SyncRequest($model));
 }

 /**
  * {@inheritDoc}
  */
 public function execute($request)
 {
     /** @var $request Sync */
     RequestNotSupportedException::assertSupports($this, $request);
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if (false == $model['token']) {
         return;
     }
     $this->payment->execute(new GetTransactionDetails($model));
     if (isset($model['error_code']) && $model['error_code'] === Errors::ERRCODE_NO_ERROR) {
         if (isset($model['transaction_status'])) {
             if ($model['transaction_status'] === TransactionStatus::PAID) {
                 $model['state'] = StateInterface::STATE_CONFIRMED;
             } else {
                 if ($model['transaction_status'] === TransactionStatus::NOT_PAID) {
                     $model['state'] = StateInterface::STATE_ERROR;
                 } else {
                     if ($model['transaction_status'] === TransactionStatus::PAID_WAITING_FOR_PROCESS) {
                         $model['state'] = StateInterface::STATE_NOTIFIED;
                     }
                 }
             }
         }
     }
 }

    /**
     * {@inheritDoc}
     */
    public function execute($request)
    {
        /** @var $request Sync */
        RequestNotSupportedException::assertSupports($this, $request);

        $this->payment->execute(new CheckAgreement($request->getModel()));
    }

 /**
  * {@inheritDoc}
  */
 public function execute($request)
 {
     RequestNotSupportedException::assertSupports($this, $request);
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if (null === $model['Signature']) {
         $request->markNew();
         return;
     }
     if ($model['Signature'] && null === $model['Status']) {
         $request->markPending();
         return;
     }
     switch ($model['Status']) {
         case Api::PAYMENT_STATUS_AUTHORIZED:
             $request->markAuthorized();
             break;
         case Api::PAYMENT_STATUS_NOT_AUTHORIZED:
             $request->markFailed();
             break;
         case Api::PAYMENT_STATUS_PAID:
             $request->markCaptured();
             break;
         case Api::PAYMENT_STATUS_CANCELED:
             $request->markCanceled();
             break;
         case Api::PAYMENT_STATUS_WAITING:
             $request->markPending();
             break;
         default:
             $request->markUnknown();
             break;
     }
 }

 /**
  * {@inheritDoc}
  */
 public function execute($request)
 {
     /** @var $request GetStatusInterface */
     RequestNotSupportedException::assertSupports($this, $request);
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if (isset($model['status'])) {
         switch ($model['status']) {
             case 'NEW':
                 $request->markNew();
                 break;
             case 'PAID':
                 $request->markCaptured();
                 break;
             case 'CANCELLED_BY_MERCHANT':
             case 'CANCELLED_BY_ADMIN':
                 $request->markCanceled();
                 break;
             case 'EXPIRED':
                 $request->markExpired();
                 break;
             case 'INVALID':
                 $request->markFailed();
                 break;
         }
     }
 }

    /**
     * {@inheritDoc}
     *
     * @param ModelAggregateInterface|ModelAwareInterface $request
     */
    public function execute($request)
    {
        RequestNotSupportedException::assertSupports($this, $request);

        /** @var DetailsAggregateInterface $model */
        $model = $request->getModel();
        $details = $model->getDetails();

        if (is_array($details)) {
            $details = ArrayObject::ensureArrayObject($details);
        }

        $request->setModel($details);
        try {
            $this->payment->execute($request);

            if ($model instanceof DetailsAwareInterface) {
                $model->setDetails($details);
            }
        } catch (\Exception $e) {
            if ($model instanceof DetailsAwareInterface) {
                $model->setDetails($details);
            }

            throw $e;
        }
    }

 /**
  * {@inheritDoc}
  *
  * @param Capture $request
  */
 public function execute($request)
 {
     /** @var $request Capture */
     RequestNotSupportedException::assertSupports($this, $request);
     $model = ArrayObject::ensureArrayObject($request->getModel());
     if (null !== $model['token']) {
         return;
     }
     if (false == $model['return_url'] && $request->getToken()) {
         $model['return_url'] = $request->getToken()->getTargetUrl();
     }
     if (false == $model['cancel_url'] && $request->getToken()) {
         $model['cancel_url'] = $request->getToken()->getTargetUrl();
     }
     $this->payment->execute(new SetExpressCheckout($model));
     if ($model['error_code'] == '00') {
         if (!isset($model['checkout_url'])) {
             throw new \LogicException('Payment gateway Nganluong is not returned "checkout_url"');
         }
         throw new HttpRedirect($model['checkout_url']);
     } else {
         return;
         // failed
     }
 }