WC_PG_Notification_Handler::processMerchantOrder() - Code Metrics - Inspection of "int-963 WIP" - pagantis/woocommerce - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#48)

unknown
created 2020-05-13 07:44 UTC
WC_PG_Notification_Handler::processMerchantOrder() A

↳ Parent: WC_PG_Notification_Handler
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	2
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	4
rs	10
<?php

use Pagantis\OrdersApiClient\Client;
use Pagantis\ModuleUtils\Exception\ConcurrencyException;
use Pagantis\ModuleUtils\Exception\AlreadyProcessedException;
use Pagantis\ModuleUtils\Exception\AmountMismatchException;
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;
use Pagantis\ModuleUtils\Model\Log\LogEntry;
use Pagantis\OrdersApiClient\Model\Order;

if (!defined('ABSPATH')) {
    exit;
}

class WC_PG_Notification_Handler extends WC_Pagantis_Gateway
{
    /**
    * Concurrency table name
    */
    const CONCURRENCY_TABLE = 'pagantis_concurrency';

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

    /**
     * Pagantis Order Number
     *
    * @var mixed $pagantisOrder
    */
    protected $pagantisOrder;

    /**
     *  Origin of Order
     *
    * @var $string $origin

    */
    public $origin;

    /**
     * WC_Order object
     *
    * @var $string

    */
    public $order;

    /**
    * @var mixed $woocommerceOrderId
    */
    protected $woocommerceOrderId = '';

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

    /**
 * @var Client $orderClient
*/
    protected $orderClient;

    /**
 * @var WC_Order $woocommerceOrder
filter:
    dependency_paths: ["lib/*"]
*/
    protected $woocommerceOrder;

    /**
 * @var mixed $pagantisOrderId
*/
    protected $pagantisOrderId = '';

    /**
     * Validation vs PagantisClient
     *
     * @return JsonExceptionResponse|JsonSuccessResponse
     * @throws ConcurrencyException
     */
    public function processInformation()
    {
        require_once dirname(__FILE__) . '/../includes/class-wc-pagantis-logger.php';
        require_once dirname(__FILE__) . '/../includes/functions.php';
        try {
            require_once(__ROOT__.'/vendor/autoload.php');
            try {
                if ($_SERVER['REQUEST_METHOD'] === 'GET' && $_GET['origin'] === 'notification') {
                    return $this->buildResponse();
                }
                $this->checkConcurrency();
                $this->getMerchantOrder();
                $this->getPagantisOrderId();
                $this->getPagantisOrder();
                $checkAlreadyProcessed = $this->checkOrderStatus();
                if ($checkAlreadyProcessed) {
                    return $this->buildResponse();
                }
                $this->validateAmount();
                if ($this->checkMerchantOrderStatus()) {
                    $this->processMerchantOrder();
                }
            } catch (\Exception $exception) {
                WC_Pagantis_Logger::insert_log_entry_in_wpdb($exception);

                return $this->buildResponse($exception);
            }

            try {
                $this->confirmPagantisOrder();

                return $this->buildResponse();
            } catch (\Exception $exception) {
                $this->rollbackMerchantOrder();
                WC_Pagantis_Logger::insert_log_entry_in_wpdb($exception);

                return $this->buildResponse($exception);
            }
        } catch (\Exception $exception) {
            WC_Pagantis_Logger::insert_log_entry_in_wpdb($exception);
            return $this->buildResponse($exception);
        }
    }

    /**
     * COMMON FUNCTIONS
     */

    /**
     * @throws ConcurrencyException
     * @throws QuoteNotFoundException
     */
    private function checkConcurrency()
    {
        $this->woocommerceOrderId = $_GET['order-received'];
        if ($this->woocommerceOrderId === '') {
            throw new QuoteNotFoundException();
        }

        $this->unblockConcurrency();
        $this->blockConcurrency($this->woocommerceOrderId);
    }

    /**
     * @throws MerchantOrderNotFoundException
     */
    private function getMerchantOrder()
    {
        try {
            $this->woocommerceOrder = new WC_Order($this->woocommerceOrderId);
            $this->woocommerceOrder->set_payment_method_title(Ucfirst(PAGANTIS_PLUGIN_ID));
        } catch (\Exception $e) {
            throw new MerchantOrderNotFoundException();
        }
    }

    /**
     * @throws NoIdentificationException
     */
    private function getPagantisOrderId()
    {
        global $wpdb;
        $this->checkDbTable();
        $tableName             = $wpdb->prefix.PAGANTIS_WC_ORDERS_TABLE;
        $queryResult           = $wpdb->get_row("select order_id from $tableName where id='".$this->woocommerceOrderId."'");
        $this->pagantisOrderId = $queryResult->order_id;

        if ($this->pagantisOrderId === '') {
            throw new NoIdentificationException();
        }
    }

    /**
     * @throws OrderNotFoundException
     */
    private function getPagantisOrder()
    {
        try {
            $this->cfg           = get_option('woocommerce_pagantis_settings');
            $this->cfg           = /** @scrutinizer ignore-call */ get_option('woocommerce_pagantis_settings');
            $this->orderClient   = new Client($this->cfg['pagantis_public_key'], $this->cfg['pagantis_private_key']);
            $this->pagantisOrder = $this->orderClient->getOrder($this->pagantisOrderId);
        } catch (\Exception $e) {
            throw new OrderNotFoundException();
        }
    }

    /**
     * @return bool
     * @throws WrongStatusException
     */
    private function checkOrderStatus()
    {
        try {
            $this->checkPagantisStatus(array('AUTHORIZED'));
        } catch (\Exception $e) {
            if ($this->pagantisOrder instanceof Order) {
                $status = $this->pagantisOrder->getStatus();
            } else {
                $status = '-';
            }

            if ($status === Order::STATUS_CONFIRMED) {
                return true;
            }
            throw new WrongStatusException($status);
        }
    }

    /**
     * @return bool
     */
    private function checkMerchantOrderStatus()
    {
        //Order status reference => https://docs.woocommerce.com/document/managing-orders/
        $validStatus   = array('on-hold', 'pending', 'failed', 'processing', 'completed');
        $isValidStatus = apply_filters(
        $isValidStatus = /** @scrutinizer ignore-call */ apply_filters(
            'woocommerce_valid_order_statuses_for_payment_complete',
            $validStatus,
            $this
        );

        if (!$this->woocommerceOrder->has_status($isValidStatus)) { // TO CONFIRM
            $logMessage = 'WARNING checkMerchantOrderStatus.' .
                          ' Merchant order id:'.$this->woocommerceOrder->get_id().
                          ' Merchant order status:'.$this->woocommerceOrder->get_status().
                          ' Pagantis order id:'.$this->pagantisOrder->getStatus().
                          ' Pagantis order status:'.$this->pagantisOrder->getId();

            WC_Pagantis_Logger::insert_log_entry_in_wpdb(null, $logMessage);
            $this->woocommerceOrder->add_order_note($logMessage);
            $this->woocommerceOrder->save();
            return false;
        }

        return true; //TO SAVE
    }

    /**
     * @throws AmountMismatchException
     */
    private function validateAmount()
    {
        $pagantisAmount = $this->pagantisOrder->getShoppingCart()->getTotalAmount();
        $wcAmount       = intval(strval(100 * $this->woocommerceOrder->get_total()));
        if ($pagantisAmount != $wcAmount) {
            throw new AmountMismatchException($pagantisAmount, $wcAmount);
        }
    }

    /**
     * @throws Exception
     */
    private function processMerchantOrder()
    {
        $this->saveOrder();
        $this->updateBdInfo();
    }

    /**
     * @return false|string
     * @throws UnknownException
     */
    private function confirmPagantisOrder()
    {
        try {
            $this->pagantisOrder = $this->orderClient->confirmOrder($this->pagantisOrderId);
        } catch (\Exception $e) {
            $this->pagantisOrder = $this->orderClient->getOrder($this->pagantisOrderId);
            if ($this->pagantisOrder->getStatus() !== Order::STATUS_CONFIRMED) {
                throw new UnknownException($e->getMessage());
            } else {
                $logMessage = 'Concurrency issue: Order_id '.$this->pagantisOrderId.' was confirmed by other process';
                WC_Pagantis_Logger::insert_log_entry_in_wpdb(null, $logMessage);
            }
        }

        $jsonResponse = new JsonSuccessResponse();
        return $jsonResponse->toJson();
    }

    /**
     * UTILS FUNCTIONS
     */
    /**
 * STEP 1 CC - Check concurrency
*/
    /**
     * Check if orders table exists
     */
    private function checkDbTable()
    {
        global $wpdb;
        $tableName = $wpdb->prefix.PAGANTIS_WC_ORDERS_TABLE;

        if ($wpdb->get_var("SHOW TABLES LIKE '$tableName'") != $tableName) {
            $charset_collate = $wpdb->get_charset_collate();
            $sql             = "CREATE TABLE $tableName (id int, order_id varchar(50), wc_order_id varchar(50), 
                  UNIQUE KEY id (id)) $charset_collate";

            require_once(ABSPATH.'wp-admin/includes/upgrade.php');

            dbDelta($sql);
            dbDelta($sql);
        }
    }

    /**
     * Check if logs table exists
     */
    private function checkDbLogTable()

    {
        global $wpdb;
        $tableName = $wpdb->prefix.PAGANTIS_LOGS_TABLE;

        if ($wpdb->get_var("SHOW TABLES LIKE '$tableName'") != $tableName) {
            $charset_collate = $wpdb->get_charset_collate();
            $sql             = "CREATE TABLE $tableName ( id int NOT NULL AUTO_INCREMENT, log text NOT NULL, 
                    createdAt timestamp DEFAULT CURRENT_TIMESTAMP, UNIQUE KEY id (id)) $charset_collate";

            require_once(ABSPATH.'wp-admin/includes/upgrade.php');

            dbDelta($sql);
            dbDelta($sql);
        }
        return;
    }

    /**
 * STEP 2 GMO - Get Merchant Order
*/
    /**
 * STEP 3 GPOI - Get Pagantis OrderId
*/
    /**
 * STEP 4 GPO - Get Pagantis Order
*/
    /**
 * STEP 5 COS - Check Order Status
*/

    /**
     * @param $statusArray
     *
     * @throws \Exception
     */
    private function checkPagantisStatus($statusArray)
    {
        $pagantisStatus = array();
        foreach ($statusArray as $status) {
            $pagantisStatus[] = constant("\Pagantis\OrdersApiClient\Model\Order::STATUS_$status");
        }

        if ($this->pagantisOrder instanceof Order) {
            $payed = in_array($this->pagantisOrder->getStatus(), $pagantisStatus);
            if (!$payed) {
                if ($this->pagantisOrder instanceof Order) {

                    $status = $this->pagantisOrder->getStatus();
                } else {
                    $status = '-';
                }
                throw new WrongStatusException($status);
            }
        } else {
            throw new OrderNotFoundException();
        }
    }

    /**
 * STEP 6 CMOS - Check Merchant Order Status
*/
    /**
 * STEP 7 VA - Validate Amount
*/
    /**
 * STEP 8 PMO - Process Merchant Order
*/
    /**
     * @throws \Exception
     */
    private function saveOrder()
    {
        global $woocommerce;
        $paymentResult = $this->woocommerceOrder->payment_complete();
        if ($paymentResult) {
            $metadataOrder = $this->pagantisOrder->getMetadata();
            $metadataInfo  = null;
            foreach ($metadataOrder as $metadataKey => $metadataValue) {
                if ($metadataKey === 'promotedProduct') {
                    $metadataInfo .= "/Producto promocionado = $metadataValue";
                }
            }

            if ($metadataInfo != null) {

                $this->woocommerceOrder->add_order_note($metadataInfo);
            }

            $this->woocommerceOrder->add_order_note("Notification received via $this->origin");
            $this->woocommerceOrder->reduce_order_stock();
            $this->woocommerceOrder->save();

            $woocommerce->cart->empty_cart();
            sleep(3);
        } else {
            throw new UnknownException('Order can not be saved');
        }
    }

    /**
     * Save the merchant order_id with the related identification
     */
    private function updateBdInfo()
    {
        global $wpdb;

        $this->checkDbTable();
        $tableName = $wpdb->prefix.PAGANTIS_WC_ORDERS_TABLE;

        $wpdb->update(
            $tableName,
            array('wc_order_id'=>$this->woocommerceOrderId),
            array('id' => $this->woocommerceOrderId),
            array('%s'),
            array('%d')
        );
    }

    /**
    * STEP 9 CPO - Confirmation Pagantis Order
    */
    private function rollbackMerchantOrder()
    {
        $this->woocommerceOrder->update_status('pending', __('Pending payment', 'woocommerce')); // phpcs:ignore WordPress.WP.I18n.TextDomainMismatch
        $this->woocommerceOrder->update_status('pending', /** @scrutinizer ignore-call */ __('Pending payment', 'woocommerce')); // phpcs:ignore WordPress.WP.I18n.TextDomainMismatch
    }

    /**
     * @param null $exception

     * @param null $message

     */
    private function insertLog($exception = null, $message = null)

    {
        global $wpdb;

        pg_wc_check_db_log_table();
        $logEntry = new LogEntry();
        if ($exception instanceof \Exception) {
            $logEntry = $logEntry->error($exception);
        } else {
            $logEntry = $logEntry->info($message);
        }

        $tableName = $wpdb->prefix.PAGANTIS_LOGS_TABLE;
        $wpdb->insert($tableName, array('log' => $logEntry->toJson()));
    }

    /**
     * @param null $orderId

     *
     * @throws ConcurrencyException
     */
    private function unblockConcurrency($orderId = null)
    {
        global $wpdb;
        $tableName = $wpdb->prefix.PAGANTIS_CONCURRENCY_TABLE;
        if ($orderId === null) {

            $query = "DELETE FROM $tableName WHERE createdAt<(NOW()- INTERVAL ".self::CONCURRENCY_TIMEOUT.' SECOND)';
        } else {
            $query = "DELETE FROM $tableName WHERE order_id = $orderId";
        }
        $resultDelete = $wpdb->query($query);
        if ($resultDelete === false) {
            throw new ConcurrencyException();
        }
    }

    /**
     * @param $orderId
     *
     * @throws ConcurrencyException
     */
    private function blockConcurrency($orderId)
    {
        global $wpdb;
        $tableName    = $wpdb->prefix.PAGANTIS_CONCURRENCY_TABLE;
        $insertResult = $wpdb->insert($tableName, array('order_id' => $orderId));
        if ($insertResult === false) {
            if ($this->getOrigin() === 'Notify') {
                throw new ConcurrencyException();
            } else {
                $query           = sprintf(
                    'SELECT TIMESTAMPDIFF(SECOND,NOW()-INTERVAL %s SECOND, createdAt) as rest FROM %s WHERE %s',
                    self::CONCURRENCY_TIMEOUT,
                    $tableName,
                    "order_id=$orderId"
                );
                $resultSeconds   = $wpdb->get_row($query);
                $restSeconds     = isset($resultSeconds) ? ($resultSeconds->rest) : 0;
                $secondsToExpire = ($restSeconds>self::CONCURRENCY_TIMEOUT) ? self::CONCURRENCY_TIMEOUT : $restSeconds;
                sleep($secondsToExpire+1);

                $logMessage = sprintf(
                    'User waiting %s seconds, default seconds %s, bd time to expire %s seconds',
                    $secondsToExpire,
                    self::CONCURRENCY_TIMEOUT,
                    $restSeconds
                );
                WC_Pagantis_Logger::insert_log_entry_in_wpdb(null, $logMessage);
            }
        }
    }

    /**
     * @param null $exception

     *
     * @return JsonExceptionResponse|JsonSuccessResponse
     * @throws ConcurrencyException
     */
    private function buildResponse($exception = null)
    {
        $this->unblockConcurrency($this->woocommerceOrderId);

        if ($exception === null) {

            $jsonResponse = new JsonSuccessResponse();
        } else {
            $jsonResponse = new JsonExceptionResponse();
            $jsonResponse->setException($exception);
        }

        $jsonResponse->setMerchantOrderId($this->woocommerceOrderId);
        $jsonResponse->setPagantisOrderId($this->pagantisOrderId);

        if ($_SERVER['REQUEST_METHOD'] === 'POST') {
            $jsonResponse->printResponse();
        } else {
            return $jsonResponse;
        }
    }

    /**
     * GETTERS & SETTERS
     */

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

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

pagantis / woocommerce

Pull Request — master (#48)

WC_PG_Notification_Handler::processMerchantOrder() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
