PagantisNotifyModuleFrontController

Complexity

Total Complexity

87

Size/Duplication

Total Lines	752
Duplicated Lines	0 %

Importance

Changes	31
Bugs	4	Features	3

23 Methods

Rating	Name	Duplication	Size	Complexity
A	finishProcess()	0	33	4
A	setOrigin()	0	3	1
A	isRedirect()	0	3	1
A	getOrigin()	0	3	1
A	unblockConcurrency()	0	10	3
B	blockConcurrency()	0	44	7
A	isPost()	0	3	1
A	processMerchantOrder()	0	47	5
A	isNotification()	0	3	1
A	isGet()	0	3	1
A	cancelProcess()	0	19	3
A	checkMerchantOrderStatus()	0	37	5
A	confirmPagantisOrder()	0	23	4
A	rollbackMerchantOrder()	0	23	3
A	validateAmount()	0	35	3
A	getMerchantOrder()	0	13	4
A	getPagantisOrderId()	0	12	3
B	prepareVariables()	0	43	8
A	checkConcurrency()	0	4	1
A	checkOrderStatus()	0	19	5
A	getMerchantOrderId()	0	16	2
F	postProcess()	0	101	19
A	getPagantisOrder()	0	6	2

<?php
/**
 * This file is part of the official Pagantis module for PrestaShop.
 *
 * @author    Pagantis <integrations@pagantis.com>
 * @copyright 2019 Pagantis
 * @license   proprietary
 */

require_once('AbstractController.php');

use Pagantis\OrdersApiClient\Client as PagantisClient;
use Pagantis\OrdersApiClient\Model\Order as PagantisModelOrder;
use Pagantis\ModuleUtils\Exception\AmountMismatchException;
use Pagantis\ModuleUtils\Exception\ConcurrencyException;
use Pagantis\ModuleUtils\Exception\MerchantOrderNotFoundException;
use Pagantis\ModuleUtils\Exception\NoIdentificationException;
use Pagantis\ModuleUtils\Exception\OrderNotFoundException;
use Pagantis\ModuleUtils\Exception\QuoteNotFoundException;
use Pagantis\ModuleUtils\Exception\UnknownException;
use Pagantis\ModuleUtils\Exception\WrongStatusException;
use Pagantis\ModuleUtils\Model\Response\JsonSuccessResponse;
use Pagantis\ModuleUtils\Model\Response\JsonExceptionResponse;

/**
 * Class PagantisNotifyModuleFrontController
 */
class PagantisNotifyModuleFrontController extends AbstractController
{
    /** Cart tablename */
    const CART_TABLE = 'pagantis_cart_process';

    /** Pagantis orders tablename */
    const ORDERS_TABLE = 'pagantis_order';

    /**
     * Seconds to expire a locked request
     */
    const CONCURRENCY_TIMEOUT = 10;

    /**
     * mismatch amount threshold in cents
     */
    const MISMATCH_AMOUNT_THRESHOLD = 5;

    /**
     * @var string $token
     */
    protected $token;

    /**
     * @var string $productName
     */
    protected $productName;

    /**
     * @var int $requestId
     */
    protected $requestId = null;

    /**
     * @var int $merchantOrderId
     */
    protected $merchantOrderId = null;

    /**
     * @var \Order $merchantOrder

The type Order was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected $merchantOrder;

    /**
     * @var int $merchantCartId
     */
    protected $merchantCartId;

    /**
     * @var \Cart $merchantCart

The type Cart was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected $merchantCart;

    /**
     * @var string $pagantisOrderId
     */
    protected $pagantisOrderId;

    /**
     * @var string $amountMismatchError
     */
    protected $amountMismatchError = '';

    /**
     * @var \Pagantis\OrdersApiClient\Model\Order $pagantisOrder
     */
    protected $pagantisOrder;

    /**
     * @var Pagantis\OrdersApiClient\Client $orderClient
     */
    protected $orderClient;

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

    /**
     * @var Object $jsonResponse
     */
    protected $jsonResponse;

    /** @var mixed $origin */
    protected $origin;

    /**
     * @throws Exception
     */
    public function postProcess()
    {
        $thrownException = false;
        $this->origin = ($this->isPost() || Tools::getValue('origin') === 'notification') ? 'Notification' : 'Order';

The type Tools was not found. Maybe you did not declare it correctly or list all dependencies?

        $this->requestId = rand(1, 999999999);

        // Validations
        try {
            //Avoiding notifications via GET
            if ($this->isGet() && $this->isNotification()) {
                echo 'OK';
                die;

Using exit here is not recommended.

            }

            $redirectMessage = sprintf(
                "Request [origin=%s][cartId=%s]",
                $this->getOrigin(),
                Tools::getValue('id_cart')
            );
            $this->saveLog(array('requestId' => $this->requestId, 'message' => $redirectMessage));

            $this->prepareVariables();
            $this->checkConcurrency();
            $this->getMerchantOrder();
            $this->getPagantisOrderId();
            $this->getPagantisOrder();
            if ($this->checkOrderStatus()) {
                $thrownException = true;

The assignment to $thrownException is dead and can be removed.

                return $this->finishProcess(false);

Are you sure the usage of $this->finishProcess(false) targeting PagantisNotifyModuleFrontController::finishProcess() seems to always return null.

            }
            $this->validateAmount();
            $this->checkMerchantOrderStatus();
        } catch (\Exception $exception) {
            $thrownException = true;
            $this->getMerchantOrderId();
            $theId = ($this->merchantOrderId)? $this->merchantOrderId : $this->merchantCartId;
            if ($this->isPost()) {
                $this->jsonResponse = new JsonExceptionResponse();
                $this->jsonResponse->setMerchantOrderId($theId);
                $this->jsonResponse->setPagantisOrderId($this->pagantisOrderId);
                $this->jsonResponse->setException($exception);
            }
            return $this->cancelProcess($exception);

Are you sure the usage of $this->cancelProcess($exception) targeting PagantisNotifyModuleFrontController::cancelProcess() seems to always return null.

        }

        // Proccess Pagantis Order
        try {
            if (!$thrownException) {

The condition $thrownException is always false.

                $this->jsonResponse = new JsonSuccessResponse();
                $this->getMerchantOrderId();
                $theId = ($this->merchantOrderId)? $this->merchantOrderId : $this->merchantCartId;
                $this->jsonResponse->setMerchantOrderId($theId);
                $this->jsonResponse->setPagantisOrderId($this->pagantisOrderId);
                $this->confirmPagantisOrder();
            }
        } catch (\Exception $exception) {
            $this->rollbackMerchantOrder();
            if ($this->isNotification()) {
                $this->getMerchantOrderId();
                $theId = ($this->merchantOrderId)? $this->merchantOrderId : $this->merchantCartId;
                $this->jsonResponse = new JsonExceptionResponse();
                $this->jsonResponse->setMerchantOrderId($theId);
                $this->jsonResponse->setPagantisOrderId($this->pagantisOrderId);
                $this->jsonResponse->setException($exception);
            }
            return $this->cancelProcess($exception);

Are you sure the usage of $this->cancelProcess($exception) targeting PagantisNotifyModuleFrontController::cancelProcess() seems to always return null.

        }

        // Process Merchant Order
        try {
            if (!$thrownException) {

The condition $thrownException is always false.

                $this->processMerchantOrder();
            }
        } catch (\Exception $exception) {
            $thrownException = true;
            $this->getMerchantOrderId();
            $theId = ($this->merchantOrderId)? $this->merchantOrderId : $this->merchantCartId;
            if ($this->isPost()) {
                $this->jsonResponse = new JsonExceptionResponse();
                $this->jsonResponse->setMerchantOrderId($theId);
                $this->jsonResponse->setPagantisOrderId($this->pagantisOrderId);
                $this->jsonResponse->setException($exception);
            }
            return $this->cancelProcess($exception);

Are you sure the usage of $this->cancelProcess($exception) targeting PagantisNotifyModuleFrontController::cancelProcess() seems to always return null.

        }

        try {
            $this->unblockConcurrency($this->merchantCartId);
        } catch (\Exception $exception) {
            $exceptionMessage = sprintf(
                "unblocking exception[origin=%s][cartId=%s][merchantOrderId=%s][pagantisOrderId=%s][%s]",
                $this->getOrigin(),
                $this->merchantCartId,
                $this->merchantOrderId,
                $this->pagantisOrderId,
                $exception->getMessage()
            );
            $this->saveLog(array('requestId' => $this->requestId, 'message' => $exceptionMessage));
        }

        return $this->finishProcess(false);

Are you sure the usage of $this->finishProcess(false) targeting PagantisNotifyModuleFrontController::finishProcess() seems to always return null.

    }

    /**
     * Check the concurrency of the purchase
     *
     * @throws Exception
     */
    public function checkConcurrency()
    {
        $this->unblockConcurrency();
        $this->blockConcurrency($this->merchantCartId);
    }

    /**
     * Find and init variables needed to process payment
     *
     * @throws Exception
     */
    public function prepareVariables()
    {
        $this->getMerchantOrderId();
        if (!empty($this->merchantOrderId)) {
            $exceptionMessage = sprintf(
                "The order %s already exists in %s table",
                $this->merchantOrderId,
                self::ORDERS_TABLE
            );
            throw new UnknownException($exceptionMessage);
        }
        $callbackOkUrl = $this->context->link->getPageLink('order-confirmation', null, null);
        $callbackKoUrl = $this->context->link->getPageLink('order', null, null, array('step'=>3));

        $this->config = array(
            'urlOK' => (Pagantis::getExtraConfig('URL_OK') !== '') ?
                Pagantis::getExtraConfig('URL_OK') : $callbackOkUrl,
            'urlKO' => (Pagantis::getExtraConfig('URL_KO') !== '') ?
                Pagantis::getExtraConfig('URL_KO') : $callbackKoUrl,
            'secureKey' => Tools::getValue('key'),
        );
        $productCode = Tools::getValue('product');
        $this->token = Tools::getValue('token');
        $products = explode(',', Pagantis::getExtraConfig('PRODUCTS', null));
        if (!in_array(Tools::strtoupper($productCode), $products)) {
            throw new UnknownException(
                'No valid Pagantis product provided in the url: ' . Tools::getValue('product')
            );
        }
        $this->productName = "Pagantis " . Tools::strtolower($productCode);

        $this->config['publicKey'] = trim(Configuration::get(Tools::strtolower($productCode) . '_public_key'));

The type Configuration was not found. Maybe you did not declare it correctly or list all dependencies?

        $this->config['privateKey'] = trim(Configuration::get(Tools::strtolower($productCode) . '_private_key'));

        $this->merchantCartId = Tools::getValue('id_cart');

        if ($this->merchantCartId == '') {
            throw new QuoteNotFoundException();
        }

        if (!($this->config['secureKey'] && Module::isEnabled(self::CODE))) {

The type Module was not found. Maybe you did not declare it correctly or list all dependencies?

            // This exception is only for Prestashop
            throw new UnknownException('Module may not be enabled');
        }
    }

    /**
     * Find prestashop Order Id
     */
    public function getMerchantOrderId()
    {
        try {
            $sql = 'select ps_order_id from ' . _DB_PREFIX_ .self::ORDERS_TABLE .' where id = '

The constant _DB_PREFIX_ was not found. Maybe you did not declare it correctly or list all dependencies?

                .(int)$this->merchantCartId . ' and token = \'' . $this->token . '\'';
            $this->merchantOrderId = Db::getInstance()->getValue($sql);

The type Db was not found. Maybe you did not declare it correctly or list all dependencies?

        } catch (\Exception $exception) {
            $exceptionMessage = sprintf(
                "getMerchantOrderId exception[origin=%s][cartId=%s][merchantOrderId=%s][pagantisOrderId=%s][%s]",
                $this->getOrigin(),
                $this->merchantCartId,
                $this->merchantOrderId,
                $this->pagantisOrderId,
                $exception->getMessage()
            );
            $this->saveLog(array('requestId' => $this->requestId, 'message' => $exceptionMessage));
        }
    }

    /**
     * Retrieve the merchant order by id
     *
     * @throws Exception
     */
    public function getMerchantOrder()
    {
        try {
            $this->merchantCart = new Cart($this->merchantCartId);
            if (!Validate::isLoadedObject($this->merchantCart)) {

The type Validate was not found. Maybe you did not declare it correctly or list all dependencies?

                // This exception is only for Prestashop
                throw new UnknownException('Unable to load cart');
            }
            if ($this->merchantCart->secure_key != $this->config['secureKey']) {
                throw new UnknownException('Secure Key is not valid');
            }
        } catch (\Exception $exception) {
            throw new MerchantOrderNotFoundException();
        }
    }

    /**
     * Find PAGANTIS Order Id
     *
     * @throws Exception
     */
    private function getPagantisOrderId()
    {
        try {
            $sql = 'select order_id from ' . _DB_PREFIX_.self::ORDERS_TABLE .' where id = '

The constant _DB_PREFIX_ was not found. Maybe you did not declare it correctly or list all dependencies?

                .(int)$this->merchantCartId . ' and token = \'' . $this->token . '\'';
            $this->pagantisOrderId= Db::getInstance()->getValue($sql);

            if (is_null($this->pagantisOrderId)) {
                throw new NoIdentificationException();
            }
        } catch (\Exception $exception) {
            throw new NoIdentificationException();
        }
    }

    /**
     * Find PAGANTIS Order in Orders Server using Pagantis\OrdersApiClient
     *
     * @throws Exception
     */
    private function getPagantisOrder()
    {
        $this->orderClient = new PagantisClient($this->config['publicKey'], $this->config['privateKey']);
        $this->pagantisOrder = $this->orderClient->getOrder($this->pagantisOrderId);
        if (!($this->pagantisOrder instanceof PagantisModelOrder)) {

$this->pagantisOrder is always a sub-type of Pagantis\OrdersApiClient\Model\Order.

            throw new OrderNotFoundException();
        }
    }

    /**
     * Compare statuses of merchant order and PAGANTIS order, witch have to be the same.
     *
     * @throws Exception
     */
    public function checkOrderStatus()
    {
        if ($this->pagantisOrder->getStatus() === PagantisModelOrder::STATUS_CONFIRMED) {
            $this->getMerchantOrderId();
            $theId = ($this->merchantOrderId)? $this->merchantOrderId : $this->merchantCartId;
            $this->jsonResponse = new JsonSuccessResponse();
            $this->jsonResponse->setMerchantOrderId($theId);
            $this->jsonResponse->setPagantisOrderId($this->pagantisOrderId);
            return true;
        }

        if ($this->pagantisOrder->getStatus() !== PagantisModelOrder::STATUS_AUTHORIZED) {
            $status = '-';
            if ($this->pagantisOrder instanceof \Pagantis\OrdersApiClient\Model\Order) {

$this->pagantisOrder is always a sub-type of Pagantis\OrdersApiClient\Model\Order.

                $status = $this->pagantisOrder->getStatus();
            }
            throw new WrongStatusException($status);
        }
        return false;
    }

    /**
     * Check that the merchant order and the order in PAGANTIS have the same amount to prevent hacking
     *
     * @throws Exception
     */
    public function validateAmount()
    {
        $totalAmount = (string) $this->pagantisOrder->getShoppingCart()->getTotalAmount();
        $merchantAmount = (string) (100 * $this->merchantCart->getOrderTotal(true));
        $merchantAmount = explode('.', explode(',', $merchantAmount)[0])[0];
        if ($totalAmount != $merchantAmount) {
            $psTotalAmount = substr_replace(
                $merchantAmount,
                '.',
                (Tools::strlen($merchantAmount) -2),
                0
            );

            $pgTotalAmountInCents = (string) $this->pagantisOrder->getShoppingCart()->getTotalAmount();
            $pgTotalAmount = substr_replace(
                $pgTotalAmountInCents,
                '.',
                (Tools::strlen($pgTotalAmountInCents) -2),
                0
            );

            $this->amountMismatchError = '. Amount mismatch in PrestaShop Cart #'. $this->merchantCartId .
                ' compared with Pagantis Order: ' . $this->pagantisOrderId .
                '. The Cart in PrestaShop has an amount of ' . $psTotalAmount . ' and in Pagantis ' .
                $pgTotalAmount . ' PLEASE REVIEW THE ORDER';

            $this->saveLog(array(
                'requestId' => $this->requestId,
                'message' => $this->amountMismatchError
            ));
            $numberPagantisAmount = (integer) $this->pagantisOrder->getShoppingCart()->getTotalAmount();
            $numberMerchantAmount = (integer) (100 * $this->merchantCart->getOrderTotal(true));
            $amountDff =  $numberMerchantAmount - $numberPagantisAmount;
            if (abs($amountDff) > self::MISMATCH_AMOUNT_THRESHOLD) {
                throw new AmountMismatchException($totalAmount, $merchantAmount);
            }
        }
    }

    /**
     * Check that the merchant order was not previously processes and is ready to be paid
     *
     * @throws Exception
     */
    public function checkMerchantOrderStatus()
    {
        try {
            if ($this->merchantCart->orderExists() !== false) {
                $exceptionMessage = sprintf(
                    "Existing Order[origin=%s][cartId=%s][merchantOrderId=%s][pagantisOrderId=%s]",
                    $this->getOrigin(),
                    $this->merchantCartId,
                    $this->merchantOrderId,
                    $this->pagantisOrderId
                );
                throw new UnknownException($exceptionMessage);
            }

            // Double check
            $tableName = _DB_PREFIX_ . self::ORDERS_TABLE;

The constant _DB_PREFIX_ was not found. Maybe you did not declare it correctly or list all dependencies?

            $fieldName = 'ps_order_id';
            $sql = ('select ' . $fieldName . ' from `' . $tableName . '` where `id` = ' . (int)$this->merchantCartId
                . ' and `order_id` = \'' . $this->pagantisOrderId . '\''
                . ' and `token` = \'' . $this->token . '\''
                . ' and `' . $fieldName . '` is not null');
            $results = Db::getInstance()->ExecuteS($sql);
            if (is_array($results) && count($results) === 1) {
                $this->getMerchantOrderId();
                $exceptionMessage = sprintf(
                    "Order was already created [origin=%s][cartId=%s][merchantOrderId=%s][pagantisOrderId=%s]",
                    $this->getOrigin(),
                    $this->merchantCartId,
                    $this->merchantOrderId,
                    $this->pagantisOrderId
                );
                throw new UnknownException($exceptionMessage);
            }
        } catch (\Exception $exception) {
            throw new UnknownException($exception->getMessage());
        }
        return true;
    }

    /**
     * Process the merchant order and notify client
     *
     * @throws Exception
     */
    public function processMerchantOrder()
    {
        try {
            $metadataOrder = $this->pagantisOrder->getMetadata();
            $metadataInfo = '';
            foreach ($metadataOrder as $metadataKey => $metadataValue) {
                if ($metadataKey == 'promotedProduct') {
                    $metadataInfo .= $metadataValue;
                }
            }

            $this->module->validateOrder(
                $this->merchantCartId,
                Configuration::get('PS_OS_PAYMENT'),
                $this->merchantCart->getOrderTotal(true),
                $this->productName,
                'pagantisOrderId: ' . $this->pagantisOrder->getId() . ' ' .
                'pagantisOrderStatus: '. $this->pagantisOrder->getStatus() .
                $this->amountMismatchError .
                $metadataInfo,
                array('transaction_id' => $this->pagantisOrderId),
                null,
                false,
                $this->config['secureKey']
            );
        } catch (\Exception $exception) {
            throw new UnknownException($exception->getMessage());
        }
        try {
            Db::getInstance()->update(
                self::ORDERS_TABLE,
                array('ps_order_id' => $this->module->currentOrder),
                'id = '. (int)$this->merchantCartId
                    . ' and order_id = \'' . $this->pagantisOrderId . '\''
                    . ' and token = \'' . $this->token . '\''
            );

        } catch (\Exception $exception) {
            $exceptionMessage = sprintf(
                "processMerchantOrder exception[origin=%s][cartId=%s][merchantOrderId=%s][pagantisOrderId=%s][%s]",
                $this->getOrigin(),
                $this->merchantCartId,
                $this->merchantOrderId,
                $this->pagantisOrderId,
                $exception->getMessage()
            );
            $this->saveLog(array('requestId' => $this->requestId, 'message' => $exceptionMessage));
        }
    }

    /**
     * Confirm the order in PAGANTIS
     *
     * @throws Exception
     */
    private function confirmPagantisOrder()
    {
        try {
            $this->orderClient->confirmOrder($this->pagantisOrderId);
            try {
                $mode = ($this->isPost()) ? 'NOTIFICATION' : 'REDIRECTION';
                $message = 'Order CONFIRMED. The order was confirmed by a ' . $mode .
                    '. Pagantis OrderId=' . $this->pagantisOrderId .
                    '. Prestashop OrderId=' . $this->module->currentOrder;
                $this->saveLog(array('requestId' => $this->requestId, 'message' => $message));
            } catch (\Exception $exception) {
                $exceptionMessage = sprintf(
                    "confirmPagantisOrder exception[origin=%s][cartId=%s][merchantOrderId=%s][pagantisOrderId=%s][%s]",
                    $this->getOrigin(),
                    $this->merchantCartId,
                    $this->merchantOrderId,
                    $this->pagantisOrderId,
                    $exception->getMessage()
                );
                $this->saveLog(array('requestId' => $this->requestId, 'message' => $exceptionMessage));
            }
        } catch (\Exception $exception) {
            throw new UnknownException(sprintf("[%s]%s", $this->getOrigin(), $exception->getMessage()));
        }
    }

    /**
     * Leave the merchant order as it was previously
     *
     * @throws Exception
     */
    public function rollbackMerchantOrder()
    {
        try {
            $this->getMerchantOrderId();
            $message = 'Roolback method: ' .
                '. Pagantis OrderId=' . $this->pagantisOrderId .
                '. Prestashop CartId=' . $this->merchantCartId .
                '. Prestashop OrderId=' . $this->merchantOrderId;
            if ($this->module->currentOrder) {
                $objOrder = new Order($this->module->currentOrder);
                $history = new OrderHistory();

The type OrderHistory was not found. Maybe you did not declare it correctly or list all dependencies?

                $history->id_order = (int)$objOrder->id;
                $history->changeIdOrderState(8, (int)($objOrder->id));
                $message .= ' Prestashop OrderId=' . $this->merchantCartId;
            }
            $this->saveLog(array(
                'requestId' => $this->requestId,
                'message' => $message
            ));
        } catch (\Exception $exception) {
            $this->saveLog(array(
                'requestId' => $this->requestId,
                'message' => $exception->getMessage()
            ));
        }
    }

    /**
     * Lock the concurrency to prevent duplicated inputs
     * @param $orderId
     *
     * @return bool
     * @throws UnknownException
     */
    protected function blockConcurrency($orderId)
    {
        try {
            $table = self::CART_TABLE;
            $insertBlock = Db::getInstance()->insert($table, array('id' =>(int)$orderId, 'timestamp' =>(time())));
            if ($insertBlock === false) {
                if ($this->isNotification()) {
                    throw new ConcurrencyException();
                } else {
                    $query = sprintf(
                        "SELECT TIMESTAMPDIFF(SECOND,NOW()-INTERVAL %s SECOND, FROM_UNIXTIME(timestamp)) 
                              as rest FROM %s WHERE %s",
                        self::CONCURRENCY_TIMEOUT,
                        _DB_PREFIX_.$table,

The constant _DB_PREFIX_ was not found. Maybe you did not declare it correctly or list all dependencies?

                        'id='.(int)$orderId
                    );
                    $resultSeconds = Db::getInstance()->getValue($query);
                    $restSeconds = isset($resultSeconds) ? ($resultSeconds) : 0;
                    $secondsToExpire = ($restSeconds>self::CONCURRENCY_TIMEOUT) ?
                        self::CONCURRENCY_TIMEOUT : $restSeconds;
                    if ($secondsToExpire > 0) {
                        sleep($secondsToExpire + 1);
                    }

                    $this->getMerchantOrderId();
                    $this->getPagantisOrderId();

                    $logMessage  = sprintf(
                        "User has waited %s seconds, default %s, bd time to expire %s [cartId=%s][origin=%s]",
                        $secondsToExpire,
                        self::CONCURRENCY_TIMEOUT,
                        $restSeconds,
                        $this->merchantCartId,
                        $this->getOrigin()
                    );

                    $this->saveLog(array('requestId' => $this->requestId, 'message' => $logMessage));

                    // After waiting...user continue the confirmation, hoping that previous call have finished.
                    return true;
                }
            }
        } catch (\Exception $exception) {
            throw new UnknownException($exception->getMessage());
        }
    }

    /**
     * @param null $orderId

Are you sure the doc-type for parameter $orderId is correct as it would always require null to be passed?

     *
     * @throws ConcurrencyException
     */
    private function unblockConcurrency($orderId = null)
    {
        try {
            if (is_null($orderId)) {

The condition is_null($orderId) is always true.

                Db::getInstance()->delete(self::CART_TABLE, 'timestamp < ' . (time() - self::CONCURRENCY_TIMEOUT));
                return;
            }
            Db::getInstance()->delete(self::CART_TABLE, 'id = ' . (int)$orderId);
        } catch (\Exception $exception) {
            throw new ConcurrencyException();
        }
    }

    /**
     * Do all the necessary actions to cancel the confirmation process in case of error
     * 1. Unblock concurrency
     * 2. Save log
     *
     * @param null $exception

Are you sure the doc-type for parameter $exception is correct as it would always require null to be passed?

     * @return mixed
     */
    public function cancelProcess($exception = null)
    {
        $debug = debug_backtrace();
        $method = $debug[1]['function'];
        $line = $debug[1]['line'];
        $this->getMerchantOrderId();
        $data = array(
            'requestId' => $this->requestId,
            'merchantCartId' => $this->merchantCartId,
            'merchantOrderId' => $this->merchantOrderId,
            'pagantisOrderId' => $this->pagantisOrderId,
            'message' => ($exception)? $exception->getMessage() : 'Unable to get Exception message',

$exception is of type null, thus it always evaluated to false.

            'statusCode' => ($exception)? $exception->getCode() : 'Unable to get Exception statusCode',

$exception is of type null, thus it always evaluated to false.

            'method' => $method,
            'file' => __FILE__,
            'line' => $line,
        );
        $this->saveLog($data);
        return $this->finishProcess(true);

Are you sure the usage of $this->finishProcess(true) targeting PagantisNotifyModuleFrontController::finishProcess() seems to always return null.

    }

    /**
     * Redirect the request to the e-commerce or show the output in json
     *
     * @param bool $error
     * @return mixed
     */
    public function finishProcess($error = true)
    {
        $this->getMerchantOrderId();
        if ($this->isPost()) {
            $returnMessage = sprintf(
                "[origin=%s][cartId=%s][prestashopOrderId=%s][pagantisOrderId=%s][message=%s]",
                $this->getOrigin(),
                $this->merchantCartId,
                $this->merchantOrderId,
                $this->pagantisOrderId,
                $this->jsonResponse->getResult()
            );
            $this->saveLog(array('requestId' => $this->requestId, 'message' => $returnMessage));
            $this->jsonResponse->printResponse();
        } else {
            $parameters = array(
                'id_cart' => $this->merchantCartId,
                'key' => $this->config['secureKey'],
                'id_module' => $this->module->id,
                'id_order' => ($this->pagantisOrder) ? $this->pagantisOrder->getId() : null,
            );
            $url = ($error)? $this->config['urlKO'] : $this->config['urlOK'];
            $returnMessage = sprintf(
                "[origin=%s][cartId=%s][prestashopOrderId=%s][pagantisOrderId=%s][returnUrl=%s]",
                $this->getOrigin(),
                $this->merchantCartId,
                $this->merchantOrderId,
                $this->pagantisOrderId,
                $url
            );
            $this->saveLog(array('requestId' => $this->requestId, 'message' => $returnMessage));

            return $this->redirect($url, $parameters);

Are you sure the usage of $this->redirect($url, $parameters) targeting AbstractController::redirect() seems to always return null.

        }
    }

    /**
     * @return bool
     */
    private function isNotification()
    {
        return ($this->getOrigin() == 'Notification');
    }

    /**
     * @return bool
     */
    private function isRedirect()

The method isRedirect() is not used, and could be removed.

    {
        return ($this->getOrigin() == 'Order');
    }

    /**
     * @return bool
     */
    private function isPost()
    {
        return $_SERVER['REQUEST_METHOD'] == 'POST';
    }

    /**
     * @return bool
     */
    private function isGet()
    {
        return $_SERVER['REQUEST_METHOD'] == 'GET';
    }

    /**
     * @return mixed
     */
    public function getOrigin()
    {
        return $this->origin;
    }

    /**
     * @param mixed $origin
     */
    public function setOrigin($origin)
    {
        $this->origin = $origin;
    }
}