Getnet\PaymentMagento\Controller\Notification\All

Complexity

Total Complexity

23

Size/Duplication

Total Lines	344
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	23	1
A	communicateStatus()	0	14	3
B	resolveStatusUpdate()	0	15	7
A	processPay()	0	28	2
A	findMageOrder()	0	16	2
A	execute()	0	53	5
A	createResult()	0	8	1
A	processCancel()	0	28	2

<?php
/**
 * Copyright © Getnet. All rights reserved.
 *
 * @author    Bruno Elisei <brunoelisei@o2ti.com>
 * See LICENSE for license details.
 */

namespace Getnet\PaymentMagento\Controller\Notification;

use Exception;
use Getnet\PaymentMagento\Gateway\Config\Config;
use Magento\Framework\App\Action\Action;
use Magento\Framework\App\Action\Context;
use Magento\Framework\Controller\Result\JsonFactory;
use Magento\Framework\Controller\ResultInterface;
use Magento\Framework\DataObjectFactory;

The type Magento\Framework\DataObjectFactory was not found. Maybe you did not declare it correctly or list all dependencies?

use Magento\Framework\View\Result\PageFactory;
use Magento\Payment\Model\Method\Logger;
use Magento\Sales\Api\Data\OrderInterfaceFactory;

The type Magento\Sales\Api\Data\OrderInterfaceFactory was not found. Maybe you did not declare it correctly or list all dependencies?

use Magento\Sales\Model\Order;
use Magento\Sales\Model\Service\InvoiceService;
use Magento\Sales\Model\Service\OrderService;
use Magento\Store\Model\StoreManagerInterface;

/**
 * Controler Notification All - Notification of receivers for All Methods.
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class All extends Action

The class Magento\Framework\App\Action\Action has been deprecated: 103.0.0 Inheritance in controllers should be avoided in favor of composition

{
    /**
     * @const string
     */
    public const APPROVED_PAID = 'APPROVED';

    /**
     * @const string
     */
    public const ACCEPT_PAID = 'PAID';

    /**
     * @const string
     */
    public const ACCEPT_PAID_ALTERNATIVE = 'AUTHORIZED';

    /**
     * @const string
     */
    public const CANCELED_PAID = 'CANCELED';

    /**
     * @const string
     */
    public const DENNY_PAID = 'DENIED';

    /**
     * @const string
     */
    public const ERROR = 'ERROR';

    /**
     * @var Logger
     */
    protected $logger;

    /**
     * @var OrderInterfaceFactory
     */
    protected $orderFactory;

    /**
     * @var PageFactory
     */
    protected $pageFactory;

    /**
     * @var StoreManagerInterface
     */
    protected $storeManager;

    /**
     * @var DataObjectFactory
     */
    protected $dataObjectFactory;

    /**
     * @var JsonFactory
     */
    protected $resultJsonFactory;

    /**
     * @var Config
     */
    protected $config;

    /**
     * @var OrderService
     */
    protected $orderService;

    /**
     * @var InvoiceService
     */
    protected $invoiceService;

    /**
     * @param Context               $context
     * @param Logger                $logger
     * @param OrderInterfaceFactory $orderFactory
     * @param PageFactory           $pageFactory
     * @param StoreManagerInterface $storeManager
     * @param DataObjectFactory     $dataObjectFactory
     * @param JsonFactory           $resultJsonFactory
     * @param Config                $config
     * @param OrderService          $orderService
     * @param InvoiceService        $invoiceService
     * @SuppressWarnings(PHPMD.ExcessiveParameterList)
     */
    public function __construct(
        Context $context,
        Logger $logger,
        OrderInterfaceFactory $orderFactory,
        PageFactory $pageFactory,
        StoreManagerInterface $storeManager,
        DataObjectFactory $dataObjectFactory,
        JsonFactory $resultJsonFactory,
        Config $config,
        OrderService $orderService,
        InvoiceService $invoiceService
    ) {
        $this->logger = $logger;
        $this->orderFactory = $orderFactory;
        $this->pageFactory = $pageFactory;
        $this->storeManager = $storeManager;
        $this->dataObjectFactory = $dataObjectFactory;
        $this->resultJsonFactory = $resultJsonFactory;
        $this->config = $config;
        $this->orderService = $orderService;
        $this->invoiceService = $invoiceService;

        return parent::__construct($context);

Are you sure the usage of parent::__construct($context) targeting Magento\Framework\App\Action\Action::__construct() seems to always return null.

    }

    /**
     * Execute.
     *
     * @return ResultInterface
     */
    public function execute()
    {
        /** @var JsonFactory $resultPage */
        $resultPage = $this->resultJsonFactory->create();

        if (!$this->getRequest()->getParams()) {
            $resultPage->setHttpResponseCode(404);

The method setHttpResponseCode() does not exist on Magento\Framework\Controller\Result\JsonFactory.

            return $resultPage;

The expression return $resultPage returns the type Magento\Framework\Controller\Result\JsonFactory which is incompatible with the documented return type Magento\Framework\Controller\ResultInterface.

        }

        $getnetData = $this->getRequest()->getParams();

        /** @var DataObjectFactory $getnetData */
        $getnetData = $this->dataObjectFactory->create(['data' => $getnetData]);

        $this->logger->debug(['type'=>'notification', 'data' => $getnetData->getData()]);

        $getnetDataSellerId = $getnetData->getSellerId();

        $sellerId = $this->config->getMerchantGatewaySellerId();

        if ($sellerId === $getnetDataSellerId) {
            $getnetDataOrderId = $getnetData->getOrderId();

            $order = $this->findMageOrder($getnetDataOrderId);

            if (!$order->getEntityId()) {

The method getEntityId() does not exist on Magento\Framework\Controller\ResultInterface.

                return $this->createResult(
                    406,
                    [
                        'error'   => 406,
                        'message' => __('Order not found.'),
                    ]
                );
            }

            if ($order->getState() !== Order::STATE_NEW) {

The method getState() does not exist on Magento\Framework\Controller\ResultInterface.

                return $this->createResult(
                    412,
                    [
                        'error'   => 412,
                        'message' => __('Not available.'),
                    ]
                );
            }

            $getnetDataStatus = $getnetData->getStatus();

            return $this->resolveStatusUpdate($getnetDataStatus, $order);
        }

        return $this->createResult(401, []);
    }

    /**
     * Resolve Status Update.
     *
     * @param string                $getnetDataStatus
     * @param OrderInterfaceFactory $order
     *
     * @return ResultInterface
     */
    public function resolveStatusUpdate($getnetDataStatus, $order)
    {
        if ($getnetDataStatus === self::APPROVED_PAID ||
            $getnetDataStatus === self::ACCEPT_PAID ||
            $getnetDataStatus === self::ACCEPT_PAID_ALTERNATIVE) {
            return $this->processPay($order);
        }

        if ($getnetDataStatus === self::CANCELED_PAID ||
            $getnetDataStatus === self::DENNY_PAID ||
            $getnetDataStatus === self::ERROR) {
            return $this->processCancel($order);
        }

        return $this->createResult(412, []);
    }

    /**
     * Find Magento Order.
     *
     * @param string $getnetDataOrderId
     *
     * @return OrderInterfaceFactory|ResultInterface
     */
    public function findMageOrder($getnetDataOrderId)
    {
        try {
            /** @var OrderInterfaceFactory $order */
            $order = $this->orderFactory->create()->load($getnetDataOrderId, 'increment_id');
        } catch (Exception $exc) {
            return $this->createResult(
                500,
                [
                    'error'   => 500,
                    'message' => $exc->getMessage(),
                ]
            );
        }

        return $order;
    }

    /**
     * Process Pay.
     *
     * @param OrderInterfaceFactory $order
     *
     * @return ResultInterface
     */
    public function processPay($order)
    {
        $totalDue = $order->getTotalDue();
        $payment = $order->getPayment();

        $payment->setNotificationResult(true);
        $payment->registerCaptureNotification($totalDue);
        $payment->accept(true);

        try {
            $order->save();
            $this->communicateStatus($order, 'pay');
        } catch (Exception $exc) {
            return $this->createResult(
                500,
                [
                    'error'   => 500,
                    'message' => $exc->getMessage(),
                ]
            );
        }

        return $this->createResult(
            200,
            [
                'order'     => $order->getIncrementId(),
                'state'     => $order->getState(),
                'status'    => $order->getStatus(),
            ]
        );
    }

    /**
     * Process Cancel.
     *
     * @param OrderInterfaceFactory $order
     *
     * @return ResultInterface
     */
    public function processCancel($order)
    {
        $totalDue = $order->getTotalDue();
        $payment = $order->getPayment();

        $payment->setNotificationResult(true);
        $payment->registerVoidNotification($totalDue);
        $payment->deny(true);

        try {
            $order->save();
            $this->communicateStatus($order, 'cancel');
        } catch (Exception $exc) {
            return $this->createResult(
                500,
                [
                    'error'   => 500,
                    'message' => $exc->getMessage(),
                ]
            );
        }

        return $this->createResult(
            200,
            [
                'order'     => $order->getIncrementId(),
                'state'     => $order->getState(),
                'status'    => $order->getStatus(),
            ]
        );
    }

    /**
     * Communicate status.
     *
     * @param OrderInterfaceFactory $order
     * @param string                $type
     *
     * @return void
     */
    public function communicateStatus($order, $type)
    {
        if ($type === 'pay') {
            $invoice = $order->getInvoiceCollection()->getFirstItem();
            $this->invoiceService->notify($invoice->getId());
        }

        if ($type === 'cancel') {
            $orderId = $order->getId();
            $comment = __('Order Canceled.');
            $history = $order->addStatusHistoryComment($comment, $order->getStatus());
            $history->setIsVisibleOnFront(true);
            $history->setIsCustomerNotified(true);
            $this->orderService->addComment($orderId, $history);
        }
    }

    /**
     * Create Result.
     *
     * @param int   $statusCode
     * @param array $data
     *
     * @return ResultInterface
     */
    public function createResult($statusCode, $data)
    {
        /** @var JsonFactory $resultPage */
        $resultPage = $this->resultJsonFactory->create();
        $resultPage->setHttpResponseCode($statusCode);
        $resultPage->setData($data);

The method setData() does not exist on Magento\Framework\Controller\Result\JsonFactory.

        return $resultPage;

The expression return $resultPage returns the type Magento\Framework\Controller\Result\JsonFactory which is incompatible with the documented return type Magento\Framework\Controller\ResultInterface.

    }
}