AbstractOrder.php

<?php

/**
 * This file contains QUI\ERP\Order\AbstractOrder
 */

namespace QUI\ERP\Order;

use QUI;
use QUI\ERP\Accounting\ArticleList;
use QUI\ERP\Accounting\Payments\Payments;
use QUI\ERP\Accounting\Payments\Transactions\Handler as TransactionHandler;
use QUI\ERP\Accounting\Payments\Transactions\Transaction;
use QUI\ERP\ErpEntityInterface;
use QUI\ERP\ErpTransactionsInterface;
use QUI\ERP\Exception;
use QUI\ERP\Order\ProcessingStatus\Handler as ProcessingHandler;
use QUI\ERP\Order\ProcessingStatus\Status;
use QUI\ERP\Order\ProcessingStatus\StatusUnknown;
use QUI\ERP\Shipping\ShippingStatus\Handler as ShippingStatusHandler;
use QUI\ERP\User;
use QUI\ExceptionStack;

use function array_filter;
use function array_flip;
use function class_exists;
use function date;
use function is_array;
use function is_numeric;
use function is_string;
use function json_decode;
use function json_encode;
use function method_exists;
use function preg_replace;
use function round;
use function strip_tags;
use function strtotime;
use function time;

/**
 * Class AbstractOrder
 *
 * Main parent class for order classes
 * - Order
 * - OrderProcess
 *
 * @package QUI\ERP\Order
 */
abstract class AbstractOrder extends QUI\QDOM implements OrderInterface, ErpEntityInterface, ErpTransactionsInterface
{
    /**
     * Article types
     */
    const ARTICLE_TYPE_PHYSICAL = 1;
    const ARTICLE_TYPE_DIGITAL = 2;
    const ARTICLE_TYPE_MIXED = 3;

    /**
     * order id
     *
     * @var integer
     */
    protected int $id;

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

    /**
     * @var ?string
     */
    protected ?string $idPrefix = null;

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

    /**
     * @var int
     */
    protected int $status = 0;

    /**
     * @var Status|StatusUnknown|null
     */
    protected Status | StatusUnknown | null $Status = null;

    /**
     * @var null|QUI\ERP\Shipping\ShippingStatus\Status
     */
    protected ?QUI\ERP\Shipping\ShippingStatus\Status $ShippingStatus = null;

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

    /**
     * invoice ID
     *
     * @var int|bool|string
     */
    protected string | int | bool | null $invoiceId = false;

    /**
     * @var string|int|null
     */
    protected null | int | string $customerId;

    /**
     * @var array|null
     */
    protected ?array $customer = [];

    /**
     * @var array|null
     */
    protected ?array $addressInvoice = [];

    /**
     * @var array|null
     */
    protected ?array $addressDelivery = [];

    /**
     * @var array
     */
    protected array $articles = [];

    /**
     * @var array|null
     */
    protected ?array $data;
    /**
     * @var array
     */
    protected array $paymentData = [];

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

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

    /**
     * Create user id
     *
     * @var integer|string
     */
    protected int | string $cUser;

    /**
     * @var ArticleList|null
     */
    protected ?ArticleList $Articles = null;

    /**
     * @var QUI\ERP\Comments|null
     */
    protected ?QUI\ERP\Comments $Comments = null;

    /**
     * @var QUI\ERP\Comments|null
     */
    protected ?QUI\ERP\Comments $History = null;

    /**
     * @var QUI\ERP\Comments|null
     */
    protected ?QUI\ERP\Comments $FrontendMessage = null;

    /**
     * @var QUI\ERP\Comments|null
     */
    protected ?QUI\ERP\Comments $StatusMails = null;

    /**
     * @var null|QUI\ERP\User
     */
    protected ?QUI\ERP\User $Customer = null;

    // payments

    /**
     * @var ?int
     */
    protected ?int $paymentId = null;

    /**
     * @var string|null
     */
    protected ?string $paymentMethod;

    /**
     * @var bool
     */
    protected bool $statusChanged = false;

    /**
     * @var QUI\ERP\Currency\Currency|null
     */
    protected ?QUI\ERP\Currency\Currency $Currency = null;

    //shipping

    /**
     * @var integer|null
     */
    protected ?int $shippingId = null;

    /**
     * Order constructor.
     *
     * @param array $data
     *
     * @throws Exception
     * @throws QUI\ERP\Exception
     */
    public function __construct(array $data = [])
    {
        $needles = Factory::getInstance()->getOrderConstructNeedles();

        foreach ($needles as $needle) {
            if (!isset($data[$needle]) && $data[$needle] !== null) {
                throw new Exception([
                    'quiqqer/order',
                    'exception.order.construct.needle.missing',
                    ['needle' => $needle]
                ]);
            }
        }

        $this->id = (int)$data['id'];
        $this->hash = $data['hash'];
        $this->cDate = $data['c_date'];
        $this->cUser = $data['c_user'];

        if (!empty($data['global_process_id'])) {
            $this->globalProcessId = $data['global_process_id'];
        } else {
            $this->globalProcessId = $this->hash;
        }

        $this->setDataBaseData($data);

        if (!empty($data['id_str'])) {
            $this->idStr = $data['id_str'];
        } else {
            $this->idStr = $this->idPrefix . $this->id;
        }

        try {
            QUI::getEvents()->fireEvent('quiqqerOrderInit', [$this]);
        } catch (\Exception $Exception) {
            QUI\System\Log::addError($Exception->getMessage());
        }
    }

    /**
     * Set the db data to the order object
     *
     * @param array $data
     *
     * @throws QUI\ERP\Exception|\Exception
     */
    protected function setDataBaseData(array $data): void
    {
        $this->invoiceId = $data['invoice_id'];
        $this->idPrefix = $data['id_prefix'];

        $this->addressDelivery = json_decode($data['addressDelivery'] ?? 'null', true);
        $this->addressInvoice = json_decode($data['addressInvoice'] ?? 'null', true);
        $this->data = json_decode($data['data'] ?? 'null', true);

        if (isset($data['status'])) {
            $this->status = $data['status'];
        }

        if (isset($data['project_name'])) {
            $this->setAttribute('project_name', $data['project_name']);
        }

        if (!empty($data['order_process_id'])) {
            $this->setAttribute('order_process_id', $data['order_process_id']);
        }

        // user
        $this->customerId = $data['customerId'];

        if (isset($data['customer'])) {
            $this->customer = json_decode($data['customer'], true);

            if (!isset($this->customer['id'])) {
                $this->customer['id'] = $this->customerId;
            }

            $customerData = $this->customer;

            if (!isset($customerData['address'])) {
                $customerData['address'] = $this->addressInvoice;
            }

            if (!isset($customerData['isCompany']) && isset($this->customer['company'])) {
                $customerData['isCompany'] = !empty($this->customer['company']);
            }

            if (!isset($customerData['country']) && isset($customerData['address']['country'])) {
                $customerData['country'] = $customerData['address']['country'];
            }

            try {
                $this->setCustomer($customerData);
            } catch (QUI\Exception $Exception) {
                QUI\System\Log::writeRecursive($this->customer);
                QUI\System\Log::addWarning($Exception->getMessage());
            }

            if (isset($this->addressInvoice['id']) && $this->addressInvoice['id'] >= 0) {
                $this->Customer->setAddress($this->getInvoiceAddress());
            } elseif (isset($customerData['address']['id']) && $customerData['address']['id']) {
                $this->Customer->setAddress($this->getInvoiceAddress());
            } elseif (isset($customerData['quiqqer.erp.address'])) {
                try {
                    $User = QUI::getUsers()->get($this->Customer->getUUID());
                    $Address = $User->getAddress($customerData['quiqqer.erp.address']);
                    $this->Customer->setAddress($Address);
                } catch (QUI\Exception $Exception) {
                    QUI\System\Log::writeDebugException($Exception);
                }
            }
        }

        // currency
        if (!empty($data['currency_data'])) {
            $currency = json_decode($data['currency_data'], true);

            if (is_string($currency)) {
                $currency = json_decode($currency, true);
            }

            if ($currency && isset($currency['code'])) {
                try {
                    $this->Currency = QUI\ERP\Currency\Handler::getCurrency($currency['code']);
                } catch (QUI\Exception $Exception) {
                    QUI\System\Log::addDebug($Exception->getMessage());
                }
            }
        }

        if ($this->Currency === null) {
            $this->Currency = QUI\ERP\Defaults::getCurrency();
        }


        // articles
        $this->Articles = new ArticleList();
        $this->Articles->setCurrency($this->Currency);

        if (isset($data['articles'])) {
            $articles = json_decode($data['articles'], true);

            if ($articles) {
                try {
                    $this->Articles = new ArticleList($articles);
                    $this->Articles->setCurrency($this->Currency);
                } catch (QUI\ERP\Exception $Exception) {
                    QUI\System\Log::addError($Exception->getMessage());
                }
            }
        }

        $Customer = $this->getCustomer();
        $Customer->setAddress($this->getDeliveryAddress());

        $this->Articles->setUser($Customer);
        $this->Articles->calc();

        // comments
        $this->Comments = new QUI\ERP\Comments();

        if (isset($data['comments'])) {
            $this->Comments = QUI\ERP\Comments::unserialize($data['comments']);
        }

        // history
        $this->History = new QUI\ERP\Comments();

        if (isset($data['history'])) {
            $this->History = QUI\ERP\Comments::unserialize($data['history']);
        }

        // frontend messages
        $this->FrontendMessage = new QUI\ERP\Comments();

        if (isset($data['frontendMessages'])) {
            $this->FrontendMessage = QUI\ERP\Comments::unserialize($data['frontendMessages']);
        }

        // status mail
        $this->StatusMails = new QUI\ERP\Comments();

        if (isset($data['status_mails'])) {
            $this->StatusMails = QUI\ERP\Comments::unserialize($data['status_mails']);
        }

        // payment
        $this->paymentId = $data['payment_id'];
        $this->successful = (int)$data['successful'];

        if ($data['paid_data'] === null) {
            $data['paid_data'] = '';
        }

        $this->setAttributes([
            'paid_status' => (int)$data['paid_status'],
            'paid_data' => json_decode($data['paid_data'], true),
            'paid_date' => $data['paid_date'],
            'temporary_invoice_id' => $data['temporary_invoice_id'],
        ]);

        if (isset($data['payment_data'])) {
            $paymentData = QUI\Security\Encryption::decrypt($data['payment_data']);
            $paymentData = json_decode($paymentData, true);

            if (is_array($paymentData)) {
                $this->paymentData = $paymentData;
            }
        }

        // shipping
        if (is_numeric($data['shipping_id'])) {
            $this->shippingId = (int)$data['shipping_id'];

            // validate shipping
            try {
                // @phpstan-ignore-next-line
                $this->validateShipping($this->getShipping());
            } catch (QUI\Exception) {
                $this->shippingId = null;
            }
        }

        try {
            $this->Status = ProcessingHandler::getInstance()->getProcessingStatus($data['status']);
            $this->status = (int)$data['status'];
        } catch (QUI\ERP\Order\ProcessingStatus\Exception) {
            // nothing
        }

        if (
            QUI::getPackageManager()->isInstalled('quiqqer/shipping')
            && isset($data['shipping_status'])
            && class_exists('QUI\ERP\Shipping\ShippingStatus\Handler')
            && class_exists('QUI\ERP\Shipping\ShippingStatus\Exception')
        ) {
            try {
                $this->ShippingStatus = ShippingStatusHandler::getInstance()->getShippingStatus(
                    $data['shipping_status']
                );
            } catch (QUI\ERP\Shipping\ShippingStatus\Exception $Exception) {
                QUI\System\Log::addWarning($Exception->getMessage());
            }
        }
    }

    /**
     * @param string $reason
     * @param QUI\Interfaces\Users\User|null $PermissionUser
     * @return ErpEntityInterface|null
     */
    public function reversal(
        string $reason = '',
        null | QUI\Interfaces\Users\User $PermissionUser = null
    ): ?ErpEntityInterface {
        $this->delete($PermissionUser);
        return null;
    }

    /**
     * Set the successful status to the order
     *
     * @throws QUI\Exception
     * @throws QUI\ExceptionStack
     */
    public function setSuccessfulStatus(): void
    {
        if ($this->successful === 1) {
            return;
        }

        $this->successful = 1;

        try {
            QUI::getEvents()->fireEvent('quiqqerOrderSuccessful', [$this]);
        } catch (\Exception $Exception) {
            QUI\System\Log::addError($Exception->getMessage());
        }

        if ($this->isApproved()) {
            $this->triggerApprovalEvent();
        }

        $this->addHistory(
            QUI::getLocale()->get(
                'quiqqer/order',
                'order.history.set_successful'
            )
        );

        $this->update();
    }

    //region API

    /**
     * Recalculate all article prices
     *
     * @param $Basket - optional
     *
     * @throws Basket\Exception
     * @throws QUI\ERP\Exception
     * @throws QUI\Exception
     */
    public function recalculate($Basket = null): void
    {
        if ($this instanceof Order) {
            $this->Articles->recalculate();
            $this->save();

            return;
        }

        if ($this instanceof OrderInProcess && $this->getOrderId()) {
            // if an order exists for the order in process
            // never recalculate it
            return;
        }

        if ($this instanceof OrderInProcess && $this->isSuccessful()) {
            // if the order is successful
            // never recalculate it
            return;
        }

        $Customer = $this->getCustomer();

        if ($Basket === null) {
            $Basket = new QUI\ERP\Order\Basket\BasketOrder($this->getUUID(), $Customer);
        }

        $ArticleList = new ArticleList();
        $ArticleList->setUser($Customer);
        $ArticleList->setCurrency($this->getCurrency());

        $ProductCalc = QUI\ERP\Products\Utils\Calc::getInstance();
        $ProductCalc->setUser($Customer);

        $Products = $Basket->getProducts();
        $Products->setUser($Customer);
        $Products->calc($ProductCalc);

        $products = $Products->getProducts();

        foreach ($products as $Product) {
            try {
                /* @var QUI\ERP\Order\Basket\Product $Product */
                $ArticleList->addArticle($Product->toArticle(null, false));
            } catch (QUI\Exception) {
                // @todo hinweis an benutzer, das artikel nicht mit aufgenommen werden konnte
            }
        }

        $Products->getPriceFactors()->clear();

        QUI::getEvents()->fireEvent(
            'quiqqerOrderBasketToOrder',
            [
                $Basket,
                $this,
                $Products
            ]
        );

        QUI::getEvents()->fireEvent(
            'quiqqerOrderBasketToOrderEnd',
            [
                $Basket,
                $this,
                $Products
            ]
        );

        $ArticleList->importPriceFactors(
            $Products->getPriceFactors()->toErpPriceFactorList()
        );

        $ArticleList->calc();

        $this->Articles = $ArticleList;
        $this->setCustomer($Customer);
        $this->update(QUI::getUsers()->getSystemUser());
    }

    /**
     * Clears the complete order
     *
     * @param QUI\Interfaces\Users\User|null $PermissionUser - optional, permission user, default = session user
     */
    abstract public function clear(null | QUI\Interfaces\Users\User $PermissionUser = null);

    /**
     * Refresh the order data
     * fetch the data from the database
     */
    abstract public function refresh();

    /**
     * Updates the order
     *
     * @param QUI\Interfaces\Users\User|null $PermissionUser - optional, permission user, default = session user
     * @throws QUI\Exception
     */
    abstract public function update(null | QUI\Interfaces\Users\User $PermissionUser = null);

    /**
     * Delete the order
     *
     * @param QUI\Interfaces\Users\User|null $PermissionUser - optional, permission user, default = session user
     */
    abstract public function delete(null | QUI\Interfaces\Users\User $PermissionUser = null);

    /**
     * Is the order posted / submitted
     *
     * @return bool
     */
    abstract public function isPosted(): bool;

    //endregion

    //region getter

    /**
     * Return the order as an array
     *
     * @return array
     */
    public function toArray(): array
    {
        $status = '';
        $shippingStatus = false;
        $paymentId = '';
        $paidStatus = [];

        $articles = $this->getArticles()->toArray();
        $Payment = $this->getPayment();
        $ProcessingStatus = $this->getProcessingStatus();

        if ($Payment) {
            $paymentId = $Payment->getId();
        }

        if ($ProcessingStatus) {
            $status = $ProcessingStatus->getId();
        }

        try {
            $paidStatus = $this->getPaidStatusInformation();
        } catch (QUI\Exception $Exception) {
            QUI\System\Log::writeDebugException($Exception);
        }

        if (class_exists('QUI\ERP\Shipping\ShippingStatus\Status') && $this->getShippingStatus()) {
            $shippingStatus = $this->getShippingStatus()->getId();
        }

        $shipping = '';

        if (class_exists('QUI\ERP\Shipping\Types\ShippingEntry') && $this->getShipping()) {
            $shipping = $this->getShipping()->getId();
        }

        return [
            'uuid' => $this->getUUID(),
            'hash' => $this->hash, // @deprecated
            'entityType' => $this->getType(),
            'globalProcessId' => $this->getGlobalProcessId(),

            'id' => $this->id,
            'prefixedId' => $this->getPrefixedNumber(),
            'prefixedNumber' => $this->getPrefixedNumber(),
            'invoiceId' => $this->invoiceId,

            'cDate' => $this->cDate,
            'cUser' => $this->cUser,
            'cUsername' => $this->getCreateUser()->getName(),
            'data' => $this->data,
            'customerId' => $this->customerId,
            'customer' => $this->getCustomer()->getAttributes(),
            'comments' => $this->getComments()->toArray(),
            'statusMails' => $this->getStatusMails()->toArray(),
            'currency' => $this->getCurrency()->toArray(),
            'project_name' => $this->getAttribute('project_name'),

            'articles' => $articles,
            'hasDeliveryAddress' => $this->hasDeliveryAddress(),
            'addressDelivery' => $this->getDeliveryAddress()->getAttributes(),
            'addressInvoice' => $this->getInvoiceAddress()->getAttributes(),
            'paymentId' => $paymentId,
            'status' => $status,
            'paidStatus' => $paidStatus,
            'shippingStatus' => $shippingStatus,
            'shipping' => $shipping,
            'shippingTracking' => $this->getDataEntry('shippingTracking'),
            'shippingConfirmation' => $this->getDataEntry('shippingConfirmation')
        ];
    }

    /**
     * Return the order id
     *
     * @return integer
     * @deprecated
     */
    public function getId(): int
    {
        return $this->id;
    }

    /**
     * @return string
     */
    public function getIdPrefix(): string
    {
        if ($this->idPrefix !== null) {
            return $this->idPrefix;
        }

        return QUI\ERP\Order\Utils\Utils::getOrderPrefix();
    }

    /**
     * Return the real order id for the customer
     *
     * @return string
     * @deprecated use getPrefixedNumber())
     */
    public function getPrefixedId(): string
    {
        return $this->getPrefixedNumber();
    }

    /**
     * @return string
     */
    public function getPrefixedNumber(): string
    {
        return $this->idStr;
    }

    /**
     * Return the order id
     * -> alias for getId(), this method is used in the calc classes
     *
     * @return integer
     */
    public function getCleanId(): int
    {
        return $this->getId();
    }

    /**
     * @return string
     */
    public function getGlobalProcessId(): string
    {
        return $this->globalProcessId;
    }

    /**
     * @return QUI\ERP\Accounting\Calculations
     *
     * @throws QUI\ERP\Exception
     * @throws QUI\Exception
     */
    public function getPriceCalculation(): QUI\ERP\Accounting\Calculations
    {
        $this->Articles->calc();

        return new QUI\ERP\Accounting\Calculations(
            $this->Articles->getCalculations(),
            $this->Articles->getArticles()
        );
    }

    /**
     * Is the order successful
     * -> Ist der Bestellablauf erfolgreich abgeschlossen
     *
     * @return int
     */
    public function isSuccessful(): int
    {
        return $this->successful;
    }

    /**
     * OrderProcess was successful and payment process was successful
     *
     * @return bool
     */
    public function isApproved(): bool
    {
        try {
            if (!$this->getPayment()) {
                return false;
            }

            $isApproved = $this->getPayment()->getPaymentType()->isApproved($this->getUUID());
            $isSuccessful = $this->isSuccessful();

            return $isApproved && $isSuccessful;
        } catch (\Exception $Exception) {
            QUI\System\Log::writeException($Exception);

            return false;
        }
    }

    /**
     * @return string
     */
    public function getInvoiceType(): string
    {
        try {
            return $this->getInvoice()->getType();
        } catch (QUI\Exception) {
            return '';
        }
    }

    /**
     * Return invoice address
     *
     * @return QUI\ERP\Address
     */
    public function getInvoiceAddress(): QUI\ERP\Address
    {
        return new QUI\ERP\Address($this->addressInvoice, $this->getCustomer());
    }

    /**
     * Return delivery address
     *
     * @return QUI\ERP\Address
     */
    public function getDeliveryAddress(): QUI\ERP\Address
    {
        $delivery = $this->addressDelivery;

        if (isset($delivery['id']) && $delivery['id'] === -1) { // quiqqer/order#156
            return $this->getInvoiceAddress();
        }

        // quiqqer/order#156
        // cleanup, to check the delivery address
        if (is_array($delivery)) {
            $delivery = array_filter($delivery);
        }

        if (isset($delivery['id'])) {
            unset($delivery['id']);
        }

        if (empty($delivery)) {
            return $this->getInvoiceAddress();
        }

        return new QUI\ERP\Address($this->addressDelivery, $this->getCustomer());
    }

    /**
     * Return the order articles list
     *
     * @return ArticleList
     */
    public function getArticles(): ArticleList
    {
        if (!$this->Articles) {
            $this->Articles = new ArticleList();
        }

        $this->Articles->setOrder($this);
        $this->Articles->setUser($this->getCustomer());
        $this->Articles->setCurrency($this->getCurrency());
        $this->Articles->calc();

        return $this->Articles;
    }

    /**
     * Return the order create date
     *
     * @return string (Y-m-d H:i:s)
     */
    public function getCreateDate(): string
    {
        return $this->cDate;
    }

    /**
     * Return the order create date
     *
     * @return QUI\Interfaces\Users\User|null
     */
    public function getCreateUser(): ?QUI\Interfaces\Users\User
    {
        try {
            return QUI::getUsers()->get($this->cUser);
        } catch (QUI\Exception $Exception) {
            QUI\System\Log::writeDebugException($Exception);
        }

        return QUI::getUsers()->getSystemUser();
    }

    /**
     * Return extra data array
     *
     * @return array
     */
    public function getData(): array
    {
        return $this->data;
    }

    /**
     * Return a data entry
     *
     * @param string $key
     * @return mixed|null
     */
    public function getDataEntry(string $key): mixed
    {
        if (isset($this->data[$key])) {
            return $this->data[$key];
        }

        return null;
    }

    /**
     * @return string
     * @deprecated use getUUID()
     */
    public function getHash(): string
    {
        return $this->getUUID();
    }

    /**
     * Return the hash
     *
     * @return string
     */
    public function getUUID(): string
    {
        return $this->hash;
    }

    /**
     * Return the customer of the order
     *
     * @return null|QUI\ERP\User
     */
    public function getCustomer(): ?QUI\ERP\User
    {
        $Nobody = QUI\ERP\User::convertUserToErpUser(QUI::getUsers()->getNobody());

        if (!$this->customerId && !$this->Customer) {
            return $Nobody;
        }

        if ($this->Customer) {
            $Address = $this->Customer->getStandardAddress();

            if (!$Address->getUUID()) {
                $this->Customer->setAddress(
                    new QUI\ERP\Address($this->addressInvoice, $this->Customer)
                );
            }

            return $this->Customer;
        }