classes/XLite/Model/Order.php line 81

Open in your IDE?
  1. <?php
  3. /**
  4.  * Copyright (c) 2011-present Qualiteam software Ltd. All rights reserved.
  5.  * See https://www.x-cart.com/license-agreement.html for license details.
  6.  */
  8. namespace XLite\Model;
  10. use ApiPlatform\Core\Annotation as ApiPlatform;
  11. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\OrderFilter;
  12. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\DBAL\LockMode;
  15. use Doctrine\ORM\EntityManager;
  16. use Doctrine\ORM\Mapping as ORM;
  17. use XCart\Domain\GmvTrackerDomain;
  18. use XCart\Framework\ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\IntegerDateFilter;
  19. use XLite\API\Endpoint\Order\DTO\OrderOutput as Output;
  20. use XLite\Core\Database;
  21. use XLite\Model\Order\Surcharge;
  22. use XLite\Model\Payment\Transaction;
  24. /**
  25.  * Class represents an order
  26.  *
  27.  * @ORM\Entity
  28.  * @ORM\Table  (name="orders",
  29.  *      indexes={
  30.  *          @ORM\Index (name="date", columns={"date"}),
  31.  *          @ORM\Index (name="total", columns={"total"}),
  32.  *          @ORM\Index (name="subtotal", columns={"subtotal"}),
  33.  *          @ORM\Index (name="tracking", columns={"tracking"}),
  34.  *          @ORM\Index (name="payment_status", columns={"payment_status_id"}),
  35.  *          @ORM\Index (name="shipping_status", columns={"shipping_status_id"}),
  36.  *          @ORM\Index (name="shipping_id", columns={"shipping_id"}),
  37.  *          @ORM\Index (name="lastRenewDate", columns={"lastRenewDate"}),
  38.  *          @ORM\Index (name="orderNumber", columns={"orderNumber"}),
  39.  *          @ORM\Index (name="is_order", columns={"is_order"}),
  40.  *          @ORM\Index (name="xcPendingExport", columns={"xcPendingExport"})
  41.  *      }
  42.  * )
  43.  *
  44.  * @ ClearDiscriminatorCondition
  45.  * @ORM\InheritanceType       ("SINGLE_TABLE")
  46.  * @ORM\DiscriminatorColumn   (name="is_order", type="integer", length=1)
  47.  * @ORM\DiscriminatorMap      ({1 = "XLite\Model\Order", 0 = "XLite\Model\Cart"})
  48.  * @ApiPlatform\ApiResource(
  49.  *     output=Output::class,
  50.  *     itemOperations={
  51.  *          "get"={
  52.  *              "method"="GET",
  53.  *              "path"="/orders/{id}.{_format}",
  54.  *              "identifiers"={"id"},
  55.  *              "requirements"={"id"="\d+"},
  56.  *              "openapi_context"={
  57.  *                  "summary"="Retrieve an order by order id",
  58.  *                  "parameters"={
  59.  *                      {"name"="id", "in"="path", "required"=true, "schema"={"type"="integer"}}
  60.  *                  }
  61.  *             },
  62.  *          },
  63.  *          "get_by_number"={
  64.  *              "method"="GET",
  65.  *              "path"="/orders/by_number/{orderNumber}.{_format}",
  66.  *              "requirements"={"orderNumber"="\w+"},
  67.  *              "identifiers"={"orderNumber"},
  68.  *              "openapi_context"={
  69.  *                  "summary"="Retrieve an order by order number",
  70.  *                  "parameters"={
  71.  *                      {"name"="orderNumber", "in"="path", "required"=true, "schema"={"type"="string"}}
  72.  *                  }
  73.  *             },
  74.  *          }
  75.  *     },
  76.  *     collectionOperations={
  77.  *          "get"={
  78.  *              "method"="GET",
  79.  *              "path"="/orders.{_format}",
  80.  *              "identifiers"={"id"}
  81.  *          }
  82.  *     }
  83.  * )
  84.  * @ApiPlatform\ApiFilter(IntegerDateFilter::class, properties={"date", "lastRenewDate"})
  85.  * @ApiPlatform\ApiFilter(OrderFilter::class, properties={"date","lastRenewDate"}, arguments={"orderParameterName"="order"})
  86.  * @ApiPlatform\ApiFilter(SearchFilter::class, properties={"paymentStatus.code"="exact", "shippingStatus.code"="exact", "profile.login"="partial"})
  87.  */
  88. class Order extends \XLite\Model\Base\SurchargeOwner
  89. {
  90.     use \XLite\Core\Cache\ExecuteCachedTrait;
  92.     /**
  93.      * Order total that is financially declared as zero (null)
  94.      */
  95.     public const ORDER_ZERO = 0.00001;
  97.     /**
  98.      * Add item error codes
  99.      */
  100.     public const NOT_VALID_ERROR = 'notValid';
  102.     public const DEFAULT_SALES_CHANNEL = 'Online store';
  104.     /**
  105.      * Order unique id
  106.      *
  107.      * @var mixed
  108.      *
  109.      * @ORM\Id
  110.      * @ORM\GeneratedValue (strategy="AUTO")
  111.      * @ORM\Column         (type="integer")
  112.      */
  113.     protected $order_id;
  115.     /**
  116.      * Order unique id
  117.      *
  118.      * @var string|null
  119.      *
  120.      * @ORM\Column (type="string", length=36, nullable=true, options={"fixed": true})
  121.      */
  122.     protected ?string $public_id = null;
  124.     /**
  125.      * Order profile
  126.      *
  127.      * @var \XLite\Model\Profile
  128.      *
  129.      * @ORM\OneToOne   (targetEntity="XLite\Model\Profile", cascade={"merge","detach","persist"})
  130.      * @ORM\JoinColumn (name="profile_id", referencedColumnName="profile_id", onDelete="CASCADE")
  131.      */
  132.     protected $profile;
  134.     /**
  135.      * Original profile
  136.      *
  137.      * @var \XLite\Model\Profile
  138.      *
  139.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Profile", cascade={"merge","detach","persist"})
  140.      * @ORM\JoinColumn (name="orig_profile_id", referencedColumnName="profile_id", onDelete="SET NULL")
  141.      */
  142.     protected $orig_profile;
  144.     /**
  145.      * Shipping method unique id
  146.      *
  147.      * @var integer
  148.      *
  149.      * @ORM\Column (type="integer")
  150.      */
  151.     protected $shipping_id = 0;
  153.     /**
  154.      * Shipping method name
  155.      *
  156.      * @var string
  157.      *
  158.      * @ORM\Column (type="string", nullable=true)
  159.      */
  160.     protected $shipping_method_name = '';
  162.     /**
  163.      * Payment method name
  164.      *
  165.      * @var string
  166.      *
  167.      * @ORM\Column (type="string", nullable=true)
  168.      */
  169.     protected $payment_method_name = '';
  171.     /**
  172.      * @var string
  173.      *
  174.      * @ORM\Column (type="string", nullable=true)
  175.      */
  176.     protected $salesChannel = self::DEFAULT_SALES_CHANNEL;
  178.     /**
  179.      * Shipping tracking code
  180.      *
  181.      * @var string
  182.      *
  183.      * @ORM\Column (type="string", length=32)
  184.      */
  185.     protected $tracking = '';
  187.     /**
  188.      * Order creation timestamp
  189.      *
  190.      * @var integer
  191.      *
  192.      * @ORM\Column (type="integer")
  193.      */
  194.     protected $date;
  196.     /**
  197.      * Last order renew date
  198.      *
  199.      * @var integer
  200.      *
  201.      * @ORM\Column (type="integer")
  202.      */
  203.     protected $lastRenewDate = 0;
  205.     /**
  206.      * Payment status
  207.      *
  208.      * @var \XLite\Model\Order\Status\Payment
  209.      *
  210.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Order\Status\Payment")
  211.      * @ORM\JoinColumn (name="payment_status_id", referencedColumnName="id", onDelete="SET NULL")
  212.      */
  213.     protected $paymentStatus;
  215.     /**
  216.      * Shipping status
  217.      *
  218.      * @var \XLite\Model\Order\Status\Shipping
  219.      *
  220.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Order\Status\Shipping")
  221.      * @ORM\JoinColumn (name="shipping_status_id", referencedColumnName="id", onDelete="SET NULL")
  222.      */
  223.     protected $shippingStatus;
  225.     /**
  226.      * Customer notes
  227.      *
  228.      * @var string
  229.      *
  230.      * @ORM\Column (type="text")
  231.      */
  232.     protected $notes = '';
  234.     /**
  235.      * Admin notes
  236.      *
  237.      * @var string
  238.      *
  239.      * @ORM\Column (type="text")
  240.      */
  241.     protected $adminNotes = '';
  243.     /**
  244.      * Order details
  245.      *
  246.      * @var \Doctrine\Common\Collections\Collection
  247.      *
  248.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderDetail", mappedBy="order", cascade={"all"})
  249.      * @ORM\OrderBy   ({"name" = "ASC"})
  250.      */
  251.     protected $details;
  253.     /**
  254.      * Order tracking numbers
  255.      *
  256.      * @var \Doctrine\Common\Collections\Collection
  257.      *
  258.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderTrackingNumber", mappedBy="order", cascade={"all"})
  259.      */
  260.     protected $trackingNumbers;
  262.     /**
  263.      * Order events queue
  264.      *
  265.      * @var \Doctrine\Common\Collections\Collection
  266.      *
  267.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderHistoryEvents", mappedBy="order", cascade={"all"})
  268.      */
  269.     protected $events;
  271.     /**
  272.      * Order items
  273.      *
  274.      * @var \Doctrine\Common\Collections\Collection|\XLite\Model\OrderItem[]
  275.      *
  276.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderItem", mappedBy="order", cascade={"all"})
  277.      */
  278.     protected $items;
  280.     /**
  281.      * Order surcharges
  282.      *
  283.      * @var \Doctrine\Common\Collections\Collection
  284.      *
  285.      * @ORM\OneToMany (targetEntity="XLite\Model\Order\Surcharge", mappedBy="owner", cascade={"all"})
  286.      * @ORM\OrderBy   ({"weight" = "ASC", "id" = "ASC"})
  287.      */
  288.     protected $surcharges;
  290.     /**
  291.      * Payment transactions
  292.      *
  293.      * @var \Doctrine\Common\Collections\Collection
  294.      *
  295.      * @ORM\OneToMany (targetEntity="XLite\Model\Payment\Transaction", mappedBy="order", cascade={"all"})
  296.      */
  297.     protected $payment_transactions;
  299.     /**
  300.      * Currency
  301.      *
  302.      * @var \XLite\Model\Currency
  303.      *
  304.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Currency", inversedBy="orders", cascade={"merge","detach"})
  305.      * @ORM\JoinColumn (name="currency_id", referencedColumnName="currency_id", onDelete="CASCADE")
  306.      */
  307.     protected $currency;
  309.     /**
  310.      * Unique order identificator (it is working for orders only, not for cart entities)
  311.      *
  312.      * @var integer
  313.      *
  314.      * @ORM\Column (type="string", length=255, nullable=true)
  315.      */
  316.     protected $orderNumber;
  318.     /**
  319.      * Recent flag: true if order's statuses were not changed manually by an administrator, otherwise - false
  320.      *
  321.      * @var boolean
  322.      *
  323.      * @ORM\Column (type="boolean")
  324.      */
  325.     protected $recent = true;
  327.     /**
  328.      * @var string
  329.      *
  330.      * @ORM\Column (type="string", length=255, nullable=true)
  331.      */
  332.     protected $stockStatus = '';
  334.     /**
  335.      * 'Add item' error code
  336.      *
  337.      * @var string
  338.      */
  339.     protected $addItemError;
  341.     /**
  342.      * Order previous payment status
  343.      *
  344.      * @var \XLite\Model\Order\Status\Payment
  345.      */
  346.     protected $oldPaymentStatus;
  348.     /**
  349.      * Flag: true - order is prepared for removing
  350.      *
  351.      * @var boolean
  352.      */
  353.     protected $isRemoving = false;
  355.     /**
  356.      * Order previous shipping status
  357.      *
  358.      * @var \XLite\Model\Order\Status\Shipping
  359.      */
  360.     protected $oldShippingStatus;
  362.     /**
  363.      * Modifiers (cache)
  364.      *
  365.      * @var \XLite\DataSet\Collection\OrderModifier
  366.      */
  367.     protected $modifiers;
  369.     /**
  370.      * Shipping carrier object cache.
  371.      * Use $this->getShippingProcessor() method to retrieve.
  372.      *
  373.      * @var \XLite\Model\Shipping\Processor\AProcessor
  374.      */
  375.     protected $shippingProcessor;
  377.     /**
  378.      * Check if notification sent by any status handler to avoid extra 'changed' notification
  379.      *
  380.      * @var boolean
  381.      */
  382.     protected $isNotificationSent = false;
  384.     /**
  385.      * Flag: Ignore sending notifications to a customer if true
  386.      *
  387.      * @var boolean
  388.      */
  389.     protected $ignoreCustomerNotifications = false;
  391.     /**
  392.      * Flag: is email notifications are allowed for the order
  393.      *
  394.      * @var boolean
  395.      */
  396.     protected $isNotificationsAllowedFlag = true;
  398.     /**
  399.      * Check status is set or not
  400.      *
  401.      * @var boolean
  402.      */
  403.     protected $statusIsSet = false;
  405.     /**
  406.      * Payment transaction sums
  407.      *
  408.      * @var array
  409.      */
  410.     protected $paymentTransactionSums;
  412.     /**
  413.      * Source address
  414.      *
  415.      * @var \XLite\Model\Address
  416.      */
  417.     protected $sourceAddress;
  419.     /**
  420.      * Flag to exporting entities
  421.      *
  422.      * @var boolean
  423.      *
  424.      * @ORM\Column (type="boolean")
  425.      */
  426.     protected $xcPendingExport = false;
  428.     /**
  429.      * Profiles
  430.      *
  431.      * @var ArrayCollection
  432.      *
  433.      * @ORM\ManyToMany (targetEntity="XLite\Model\Order")
  434.      * @ORM\JoinTable  (
  435.      *      name="order_backorder_competitors",
  436.      *      joinColumns={@ORM\JoinColumn(name="id", referencedColumnName="order_id", onDelete="CASCADE")},
  437.      *      inverseJoinColumns={@ORM\JoinColumn(name="competitor_id", referencedColumnName="order_id", onDelete="CASCADE")}
  438.      * )
  439.      */
  440.     protected $backorderCompetitors;
  442.     protected $backorderProductAmounts = [];
  444.     /**
  445.      * If entity temporary
  446.      *
  447.      * @var bool
  448.      */
  449.     protected $temporary = false;
  451.     /**
  452.      * @return boolean
  453.      */
  454.     public function isTemporary()
  455.     {
  456.         return $this->temporary;
  457.     }
  459.     /**
  460.      * @param boolean $temporary
  461.      */
  462.     public function setTemporary($temporary)
  463.     {
  464.         $this->temporary = $temporary;
  465.     }
  467.     /**
  468.      * Flag if cart become order in current runtime
  469.      *
  470.      * @var bool
  471.      */
  472.     protected $justClosed = false;
  474.     /**
  475.      * @return bool
  476.      */
  477.     public function isJustClosed()
  478.     {
  479.         return $this->justClosed;
  480.     }
  482.     /**
  483.      * @param bool $justClosed
  484.      */
  485.     protected function setJustClosed($justClosed)
  486.     {
  487.         $this->justClosed = $justClosed;
  488.     }
  490.     /**
  491.      * Add item to order
  492.      *
  493.      * @param \XLite\Model\OrderItem $newItem Item to add
  494.      *
  495.      * @return boolean
  496.      */
  497.     public function addItem(\XLite\Model\OrderItem $newItem)
  498.     {
  499.         $result = false;
  501.         if ($newItem->isValid() && $newItem->isConfigured()) {
  502.             $this->addItemError = null;
  503.             $newItem->setOrder($this);
  505.             $item = $this->getItemByItem($newItem);
  507.             $warningText = '';
  509.             if ($item) {
  510.                 $warningText = $item->getAmountWarning(
  511.                     $item->getAmount() + $newItem->getAmount()
  512.                 );
  514.                 $item->setAmount($item->getAmount() + $newItem->getAmount());
  515.                 $item->refreshUpdateDate();
  516.             } else {
  517.                 $newItem->refreshUpdateDate();
  518.                 $this->addItems($newItem);
  519.             }
  521.             $result = $warningText === '';
  523.             if ($warningText !== '') {
  524.                 \XLite\Core\TopMessage::addWarning($warningText);
  525.             }
  526.         } else {
  527.             $this->addItemError = static::NOT_VALID_ERROR;
  528.         }
  530.         return $result;
  531.     }
  533.     /**
  534.      * Remove item from order
  535.      *
  536.      * @param \XLite\Model\OrderItem $item
  537.      */
  538.     public function removeItem(\XLite\Model\OrderItem $item)
  539.     {
  540.         if ($item->getAmount() > 1) {
  541.             $item->setAmount($item->getAmount() - 1);
  542.         } else {
  543.             $this->getItems()->removeElement($item);
  544.             \XLite\Core\Database::getEM()->remove($item);
  545.         }
  546.     }
  548.     /**
  549.      * Get 'Add item' error code
  550.      *
  551.      * @return string|void
  552.      */
  553.     public function getAddItemError()
  554.     {
  555.         return $this->addItemError;
  556.     }
  558.     /**
  559.      * Get item from order by another item
  560.      *
  561.      * @param \XLite\Model\OrderItem $item Another item
  562.      *
  563.      * @return \XLite\Model\OrderItem|void
  564.      */
  565.     public function getItemByItem(\XLite\Model\OrderItem $item)
  566.     {
  567.         return $this->getItemByItemKey($item->getKey());
  568.     }
  570.     /**
  571.      * Get item from order by item key
  572.      *
  573.      * @param string $key Item key
  574.      *
  575.      * @return \XLite\Model\OrderItem|void
  576.      */
  577.     public function getItemByItemKey($key)
  578.     {
  579.         $items = $this->getItems();
  581.         return \Includes\Utils\ArrayManager::findValue(
  582.             $items,
  583.             [$this, 'checkItemKeyEqual'],
  584.             $key
  585.         );
  586.     }
  588.     /**
  589.      * Get item from order by item  id
  590.      *
  591.      * @param integer $itemId Item id
  592.      *
  593.      * @return \XLite\Model\OrderItem|void
  594.      */
  595.     public function getItemByItemId($itemId)
  596.     {
  597.         $items = $this->getItems();
  599.         return \Includes\Utils\ArrayManager::findValue(
  600.             $items,
  601.             [$this, 'checkItemIdEqual'],
  602.             $itemId
  603.         );
  604.     }
  606.     /**
  607.      * Find items by product ID
  608.      *
  609.      * @param integer $productId Product ID to use
  610.      *
  611.      * @return array
  612.      */
  613.     public function getItemsByProductId($productId)
  614.     {
  615.         $items = $this->getItems();
  617.         return \Includes\Utils\ArrayManager::filter(
  618.             $items,
  619.             [$this, 'isItemProductIdEqual'],
  620.             $productId
  621.         );
  622.     }
  624.     /**
  625.      * Normalize items
  626.      *
  627.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  628.      *
  629.      * @return void
  630.      */
  631.     public function normalizeItems()
  632.     {
  633.         // Normalize by key
  634.         $keys = [];
  636.         foreach ($this->getItems() as $item) {
  637.             $key = $item->getKey();
  638.             if (isset($keys[$key])) {
  639.                 $keys[$key]->setAmount($keys[$key]->getAmount() + $item->getAmount());
  640.                 $this->getItems()->removeElement($item);
  642.                 if (\XLite\Core\Database::getEM()->contains($item)) {
  643.                     \XLite\Core\Database::getEM()->remove($item);
  644.                 }
  645.             } else {
  646.                 $keys[$key] = $item;
  647.             }
  648.         }
  650.         unset($keys);
  652.         // Remove invalid items
  653.         foreach ($this->getItems() as $item) {
  654.             if (!$item->isValid()) {
  655.                 $this->getItems()->removeElement($item);
  656.                 if (\XLite\Core\Database::getEM()->contains($item)) {
  657.                     \XLite\Core\Database::getEM()->remove($item);
  658.                 }
  659.             }
  660.         }
  661.     }
  663.     /**
  664.      * Return items number
  665.      *
  666.      * @return integer
  667.      */
  668.     public function countItems()
  669.     {
  670.         return count($this->getItems());
  671.     }
  673.     /**
  674.      * Return order items total quantity
  675.      *
  676.      * @return integer
  677.      */
  678.     public function countQuantity()
  679.     {
  680.         $quantity = 0;
  682.         foreach ($this->getItems() as $item) {
  683.             $quantity += $item->getAmount();
  684.         }
  686.         return $quantity;
  687.     }
  689.     /**
  690.      * Get failure reason
  691.      *
  692.      * @return string
  693.      */
  694.     public function getFailureReason()
  695.     {
  696.         $transactions = $this->getPaymentTransactions()->getValues();
  697.         /** @var \XLite\Model\Payment\Transaction $transaction */
  698.         foreach (array_reverse($transactions) as $transaction) {
  699.             if ($transaction->isFailed()) {
  700.                 if ($transaction->getNote() && $transaction->getNote() !== Transaction::getDefaultFailedReason()) {
  701.                     return $transaction->getNote();
  702.                 }
  704.                 $reason = $transaction->getDataCell('status');
  706.                 if ($reason && $reason->getValue()) {
  707.                     return $reason->getValue();
  708.                 }
  709.             }
  710.         }
  712.         return null;
  713.     }
  715.     /**
  716.      * Checks whether the shopping cart/order is empty
  717.      *
  718.      * @return boolean
  719.      */
  720.     public function isEmpty()
  721.     {
  722.         return 0 >= $this->countItems();
  723.     }
  725.     /**
  726.      * Check order subtotal
  727.      *
  728.      * @return boolean
  729.      */
  730.     public function isMinOrderAmountError()
  731.     {
  732.         return $this->getSubtotal() < \XLite\Core\Config::getInstance()->General->minimal_order_amount;
  733.     }
  735.     /**
  736.      * Check order subtotal
  737.      *
  738.      * @return boolean
  739.      */
  740.     public function isMaxOrderAmountError()
  741.     {
  742.         return $this->getSubtotal() > \XLite\Core\Config::getInstance()->General->maximal_order_amount;
  743.     }
  745.     /**
  746.      * Return printable order number
  747.      *
  748.      * @return string
  749.      */
  750.     public function getPrintableOrderNumber()
  751.     {
  752.         $orderNumber = (string) $this->getOrderNumber();
  754.         return '#' . str_repeat('0', 5 - min(5, strlen($orderNumber))) . $orderNumber;
  755.     }
  757.     /**
  758.      * Check - is order processed or not
  759.      *
  760.      * @return boolean
  761.      */
  762.     public function isProcessed()
  763.     {
  764.         return in_array(
  765.             $this->getPaymentStatusCode(),
  766.             [
  767.                 \XLite\Model\Order\Status\Payment::STATUS_PART_PAID,
  768.                 \XLite\Model\Order\Status\Payment::STATUS_PAID,
  769.             ],
  770.             true
  771.         );
  772.     }
  774.     /**
  775.      * Check - is order queued or not
  776.      *
  777.      * @return boolean
  778.      */
  779.     public function isQueued()
  780.     {
  781.         return $this->getPaymentStatusCode() === \XLite\Model\Order\Status\Payment::STATUS_QUEUED;
  782.     }
  784.     /**
  785.      * Check item amounts
  786.      *
  787.      * @return array
  788.      */
  789.     public function getItemsWithWrongAmounts()
  790.     {
  791.         $items = [];
  792.         foreach ($this->getItems() as $item) {
  793.             if ($item->hasWrongAmount()) {
  794.                 $items[] = $item;
  795.             }
  796.         }
  798.         return $items;
  799.     }
  801.     /**
  802.      * Set profile
  803.      *
  804.      * @param \XLite\Model\Profile $profile Profile OPTIONAL
  805.      *
  806.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  807.      *
  808.      * @return void
  809.      */
  810.     public function setProfile(\XLite\Model\Profile $profile = null)
  811.     {
  812.         if (
  813.             $this->getProfile()
  814.             && $this->getProfile()->getOrder()
  815.             && (!$profile || $this->getProfile()->getProfileId() != $profile->getProfileId())
  816.         ) {
  817.             $this->getProfile()->setOrder(null);
  818.             if ($this->getProfile()->getAnonymous() && $profile && !$profile->getAnonymous()) {
  819.                 \XLite\Core\Database::getEM()->remove($this->getProfile());
  820.             }
  821.         }
  823.         $this->profile = $profile;
  824.     }
  826.     /**
  827.      * Set original profile
  828.      * FIXME: is it really needed?
  829.      *
  830.      * @param \XLite\Model\Profile $profile Profile OPTIONAL
  831.      *
  832.      * @return void
  833.      */
  834.     public function setOrigProfile(\XLite\Model\Profile $profile = null)
  835.     {
  836.         if (
  837.             $this->getOrigProfile()
  838.             && $this->getOrigProfile()->getOrder()
  839.             && (!$profile || $this->getOrigProfile()->getProfileId() != $profile->getProfileId())
  840.             && (!$this->getProfile() || $this->getOrigProfile()->getProfileId() != $this->getProfile()->getProfileId())
  841.         ) {
  842.             $this->getOrigProfile()->setOrder(null);
  843.         }
  845.         $this->orig_profile = $profile;
  846.     }
  848.     /**
  849.      * Set profile copy
  850.      *
  851.      * @param \XLite\Model\Profile $profile Profile
  852.      *
  853.      * @return void
  854.      */
  855.     public function setProfileCopy(\XLite\Model\Profile $profile)
  856.     {
  857.         // Set profile as original profile
  858.         $this->setOrigProfile($profile);
  860.         // Clone profile and set as order profile
  861.         $clonedProfile = $profile->cloneEntity();
  862.         $this->setProfile($clonedProfile);
  863.         $clonedProfile->setOrder($this);
  864.     }
  866.     // {{{ Clone
  868.     /**
  869.      * clone Order as temporary
  870.      *
  871.      * @return \XLite\Model\Order
  872.      */
  873.     public function cloneOrderAsTemporary()
  874.     {
  875.         $isTemporary = $this->isTemporary();
  876.         $this->setTemporary(true);
  877.         $result = $this->cloneEntity();
  878.         $result->setOrderNumber(null);
  879.         $result->setIsNotificationsAllowedFlag(null);
  880.         $result->setTemporary(true);
  881.         $this->setTemporary($isTemporary);
  883.         return $result;
  884.     }
  886.     /**
  887.      * Clone order and all related data
  888.      *
  889.      * @return \XLite\Model\Order
  890.      */
  891.     public function cloneEntity()
  892.     {
  893.         // Clone order
  894.         $newOrder = parent::cloneEntity();
  896.         $this->cloneEntityAssignOrderNumber($newOrder);
  897.         $this->cloneEntityProfile($newOrder);
  898.         $this->cloneEntityCurrency($newOrder);
  899.         $this->cloneEntityOrderStatuses($newOrder);
  900.         $this->cloneOrderItems($newOrder);
  901.         $this->cloneEntityOrderDetails($newOrder);
  902.         $this->cloneEntityTrackingNumbers($newOrder);
  903.         $this->cloneEntityEvents($newOrder);
  904.         $this->cloneEntitySurcharges($newOrder);
  905.         $this->cloneEntityPaymentTransactions($newOrder);
  907.         return $newOrder;
  908.     }
  910.     /**
  911.      * @return string|null
  912.      */
  913.     public function getStockStatus()
  914.     {
  915.         return $this->stockStatus;
  916.     }
  918.     /**
  919.      * @param string|null $stockStatus
  920.      */
  921.     public function setStockStatus($stockStatus)
  922.     {
  923.         $this->stockStatus = $stockStatus;
  924.     }
  926.     /**
  927.      * Assign order number for cloned entity
  928.      *
  929.      * @param \XLite\Model\Order $newOrder
  930.      * @throws \Doctrine\ORM\ORMException
  931.      */
  932.     protected function cloneEntityAssignOrderNumber($newOrder)
  933.     {
  934.         if ($this->getOrderNumber() && !$this->isTemporary()) {
  935.             $newOrder->setOrderNumber(
  936.                 \XLite\Core\Database::getRepo('XLite\Model\Order')->findNextOrderNumber()
  937.             );
  938.         }
  939.     }
  941.     /**
  942.      * Assign profiles for cloned entity
  943.      *
  944.      * @param \XLite\Model\Order $newOrder
  945.      */
  946.     protected function cloneEntityProfile($newOrder)
  947.     {
  948.         $newOrder->setOrigProfile($this->getOrigProfile());
  950.         if ($this->getProfile()) {
  951.             $clonedProfile = $this->getProfile()->cloneEntity();
  952.             $newOrder->setProfile($clonedProfile);
  953.             $clonedProfile->setOrder($newOrder);
  954.         }
  955.     }
  957.     /**
  958.      * Assign currency for cloned entity
  959.      *
  960.      * @param \XLite\Model\Order $newOrder
  961.      */
  962.     protected function cloneEntityCurrency($newOrder)
  963.     {
  964.         $newOrder->setCurrency($this->getCurrency());
  965.     }
  967.     /**
  968.      * Assign order statuses for cloned entity
  969.      *
  970.      * @param \XLite\Model\Order $newOrder
  971.      */
  972.     protected function cloneEntityOrderStatuses($newOrder)
  973.     {
  974.         $newOrder->setPaymentStatus($this->getPaymentStatus());
  975.         $newOrder->setShippingStatus($this->getShippingStatus());
  976.     }
  978.     /**
  979.      * Assign order details for cloned entity
  980.      *
  981.      * @param \XLite\Model\Order $newOrder
  982.      */
  983.     protected function cloneEntityOrderDetails($newOrder)
  984.     {
  985.         foreach ($this->getDetails() as $detail) {
  986.             $clonedDetails = $detail->cloneEntity();
  987.             $newOrder->addDetails($clonedDetails);
  988.             $clonedDetails->setOrder($newOrder);
  989.         }
  990.     }
  992.     /**
  993.      * Assign tracking numbers for cloned entity
  994.      *
  995.      * @param \XLite\Model\Order $newOrder
  996.      */
  997.     protected function cloneEntityTrackingNumbers($newOrder)
  998.     {
  999.         foreach ($this->getTrackingNumbers() as $tn) {
  1000.             $clonedTN = $tn->cloneEntity();
  1001.             $newOrder->addTrackingNumbers($clonedTN);
  1002.             $clonedTN->setOrder($newOrder);
  1003.         }
  1004.     }
  1006.     /**
  1007.      * Assign events for cloned entity
  1008.      *
  1009.      * @param \XLite\Model\Order $newOrder
  1010.      */
  1011.     protected function cloneEntityEvents($newOrder)
  1012.     {
  1013.         foreach ($this->getEvents() as $event) {
  1014.             $cloned = $event->cloneEntity();
  1015.             $newOrder->addEvents($cloned);
  1016.             $cloned->setOrder($newOrder);
  1017.             $cloned->setAuthor($event->getAuthor());
  1018.         }
  1019.     }
  1021.     /**
  1022.      * Assign surcharges for cloned entity
  1023.      *
  1024.      * @param \XLite\Model\Order $newOrder
  1025.      */
  1026.     protected function cloneEntitySurcharges($newOrder)
  1027.     {
  1028.         foreach ($this->getSurcharges() as $surcharge) {
  1029.             $cloned = $surcharge->cloneEntity();
  1030.             $newOrder->addSurcharges($cloned);
  1031.             $cloned->setOwner($newOrder);
  1032.         }
  1033.     }
  1035.     /**
  1036.      * Assign payment transactions for cloned entity
  1037.      *
  1038.      * @param \XLite\Model\Order $newOrder
  1039.      */
  1040.     protected function cloneEntityPaymentTransactions($newOrder)
  1041.     {
  1042.         foreach ($this->getPaymentTransactions() as $pt) {
  1043.             $cloned = $pt->cloneEntity();
  1044.             $newOrder->addPaymentTransactions($cloned);
  1045.             $cloned->setOrder($newOrder);
  1046.         }
  1047.     }
  1049.     /**
  1050.      * Clone order items
  1051.      *
  1052.      * @param \XLite\Model\Order $newOrder New Order
  1053.      *
  1054.      * @return void
  1055.      */
  1056.     protected function cloneOrderItems($newOrder)
  1057.     {
  1058.         // Clone order items
  1059.         foreach ($this->getItems() as $item) {
  1060.             $clonedItem = $item->cloneEntity();
  1061.             $clonedItem->setOrder($newOrder);
  1062.             $newOrder->addItems($clonedItem);
  1063.         }
  1064.     }
  1066.     // }}}
  1068.     /**
  1069.      * Get shipping method name
  1070.      *
  1071.      * @return string
  1072.      */
  1073.     public function getShippingMethodName()
  1074.     {
  1075.         $shipping = \XLite\Core\Database::getRepo('XLite\Model\Shipping\Method')->find($this->getShippingId());
  1077.         return $shipping ? $shipping->getName() : $this->shipping_method_name;
  1078.     }
  1080.     /**
  1081.      * Get payment method name
  1082.      *
  1083.      * @return string
  1084.      */
  1085.     public function getPaymentMethodName()
  1086.     {
  1087.         $paymentMethod = $this->getPaymentMethod();
  1089.         return $paymentMethod ? $paymentMethod->getName() : $this->payment_method_name;
  1090.     }
  1092.     /**
  1093.      * Get payment method name
  1094.      *
  1095.      * @return string
  1096.      */
  1097.     public function getPaymentMethodId()
  1098.     {
  1099.         $paymentMethod = $this->getPaymentMethod();
  1101.         return $paymentMethod ? $paymentMethod->getMethodId() : null;
  1102.     }
  1104.     /**
  1105.      * Set old payment status of the order (not stored in the DB)
  1106.      *
  1107.      * @param string $paymentStatus Payment status
  1108.      *
  1109.      * @return void
  1110.      */
  1111.     public function setOldPaymentStatus($paymentStatus)
  1112.     {
  1113.         $this->oldPaymentStatus = $paymentStatus;
  1114.     }
  1116.     /**
  1117.      * Set old shipping status of the order (not stored in the DB)
  1118.      *
  1119.      * @param string $shippingStatus Shipping status
  1120.      *
  1121.      * @return void
  1122.      */
  1123.     public function setOldShippingStatus($shippingStatus)
  1124.     {
  1125.         $this->oldShippingStatus = $shippingStatus;
  1126.     }
  1128.     /**
  1129.      * Get items list fingerprint by amount and key
  1130.      *
  1131.      * @return string
  1132.      */
  1133.     public function getItemsAmountKeyFingerprint()
  1134.     {
  1135.         $result = false;
  1137.         if (!$this->isEmpty()) {
  1138.             $items = [];
  1139.             foreach ($this->getItems() as $item) {
  1140.                 $items[] = [
  1141.                     $item->getKey(),
  1142.                     $item->getAmount()
  1143.                 ];
  1144.             }
  1146.             $result = md5(serialize($items));
  1147.         }
  1149.         return $result;
  1150.     }
  1152.     /**
  1153.      * Get items list fingerprint
  1154.      *
  1155.      * @return string
  1156.      */
  1157.     public function getItemsFingerprint()
  1158.     {
  1159.         $result = false;
  1161.         if (!$this->isEmpty()) {
  1162.             $items = [];
  1163.             foreach ($this->getItems() as $item) {
  1164.                 $items[] = [
  1165.                     $item->getItemId(),
  1166.                     $item->getKey(),
  1167.                     $item->getAmount()
  1168.                 ];
  1169.             }
  1171.             $result = md5(serialize($items));
  1172.         }
  1174.         return $result;
  1175.     }
  1177.     /**
  1178.      * Get fingerprint of cart items corresponding to specific product id
  1179.      *
  1180.      * @param integer $productId
  1181.      *
  1182.      * @return string
  1183.      */
  1184.     public function getItemsFingerprintByProductId($productId)
  1185.     {
  1186.         $result = false;
  1188.         if (!$this->isEmpty()) {
  1189.             $items = [];
  1190.             foreach ($this->getItems() as $item) {
  1191.                 if ($item->getObject() && $item->getObject()->getId() == $productId) {
  1192.                     $items[] = [
  1193.                         $item->getItemId(),
  1194.                         $item->getKey(),
  1195.                         $item->getAmount(),
  1196.                     ];
  1197.                 }
  1198.             }
  1200.             $result = md5(serialize($items));
  1201.         }
  1203.         return $result;
  1204.     }
  1206.     /**
  1207.      * Generate a string representation of the order
  1208.      * to send to a payment service
  1209.      *
  1210.      * @return string
  1211.      */
  1212.     public function getDescription()
  1213.     {
  1214.         $result = [];
  1216.         foreach ($this->getItems() as $item) {
  1217.             $result[] = $item->getDescription();
  1218.         }
  1220.         return implode("\n", $result);
  1221.     }
  1223.     /**
  1224.      * Get order fingerprint for event subsystem
  1225.      *
  1226.      * @param array $exclude Exclude kes OPTIONAL
  1227.      *
  1228.      * @return array
  1229.      */
  1230.     public function getEventFingerprint(array $exclude = [])
  1231.     {
  1232.         $keys = array_diff($this->defineFingerprintKeys(), $exclude);
  1234.         $hash = [];
  1235.         foreach ($keys as $key) {
  1236.             $method = 'getFingerprintBy' . ucfirst($key);
  1237.             $hash[$key] = $this->$method();
  1238.         }
  1240.         return $hash;
  1241.     }
  1243.     /**
  1244.      * Returns delivery source address
  1245.      *
  1246.      * @return \XLite\Model\Address
  1247.      */
  1248.     public function getSourceAddress()
  1249.     {
  1250.         if ($this->sourceAddress === null) {
  1251.             $address = new \XLite\Model\Address();
  1253.             $config = $this->getSourceAddressConfiguration();
  1255.             $address->setAddress1($config->origin_address1);
  1256.             $address->setAddress2($config->origin_address2);
  1257.             $address->setAddress3($config->origin_address3);
  1258.             $address->setCity($config->origin_city);
  1259.             $address->setCountryCode($config->origin_country);
  1260.             $address->setName($config->company_name);
  1262.             if ($config->origin_state) {
  1263.                 $address->setStateId($config->origin_state);
  1264.             }
  1266.             if ($config->origin_custom_state) {
  1267.                 $address->setCustomState($config->origin_custom_state);
  1268.             }
  1270.             $address->setZipcode($config->origin_zipcode);
  1271.             $address->setPhone($config->company_phone);
  1273.             $this->sourceAddress = $address;
  1274.         }
  1276.         return $this->sourceAddress;
  1277.     }
  1279.     /**
  1280.      * Returns company configuration for getSourceAddress()
  1281.      *
  1282.      * @return \XLite\Core\ConfigCell
  1283.      */
  1284.     protected function getSourceAddressConfiguration()
  1285.     {
  1286.         return \XLite\Core\Config::getInstance()->Company;
  1287.     }
  1289.     /**
  1290.      * Returns company configuration
  1291.      *
  1292.      * @return \XLite\Core\ConfigCell
  1293.      */
  1294.     public function getCompanyConfiguration()
  1295.     {
  1296.         return \XLite\Core\Config::getInstance()->Company;
  1297.     }
  1299.     /**
  1300.      * Define fingerprint keys
  1301.      *
  1302.      * @return array
  1303.      */
  1304.     protected function defineFingerprintKeys()
  1305.     {
  1306.         return [
  1307.             'items',
  1308.             'itemsCount',
  1309.             'shippingTotal',
  1310.             'total',
  1311.             'shippingMethodId',
  1312.             'freeShippingNote',
  1313.             'paymentMethodId',
  1314.             'shippingMethodsHash',
  1315.             'paymentMethodsHash',
  1316.             'shippingAddressId',
  1317.             'billingAddressId',
  1318.             'shippingAddressFields',
  1319.             'billingAddressFields',
  1320.             'sameAddress',
  1321.         ];
  1322.     }
  1324.     /**
  1325.      * Get fingerprint by 'items' key
  1326.      *
  1327.      * @return array
  1328.      */
  1329.     protected function getFingerprintByItems()
  1330.     {
  1331.         $list = [];
  1333.         foreach ($this->getItems() as $item) {
  1334.             $event = $item->getEventCell();
  1336.             // float is intended here to adopt fractional quantities via modules
  1337.             $event['quantity'] = (float) $item->getAmount();
  1339.             if ($this instanceof \XLite\Model\Cart && $this->isItemLimitReached($item)) {
  1340.                 $event['is_limit'] = 1;
  1341.             }
  1343.             $list[] = $event;
  1344.         }
  1346.         return $list;
  1347.     }
  1349.     /**
  1350.      * Return true if item amount limit is reached
  1351.      *
  1352.      * @param \XLite\Model\OrderItem $item Order item
  1353.      *
  1354.      * @return boolean
  1355.      */
  1356.     protected function isItemLimitReached($item)
  1357.     {
  1358.         $result = false;
  1360.         $object = $item->getObject();
  1362.         if ($object) {
  1363.             $result = $object->getInventoryEnabled() && $object->getPublicAmount() <= $item->getAmount();
  1364.         }
  1366.         return $result;
  1367.     }
  1369.     /**
  1370.      * Get fingerprint by 'itemsCount' key
  1371.      *
  1372.      * @return int
  1373.      */
  1374.     protected function getFingerprintByItemsCount()
  1375.     {
  1376.         return (int) $this->countQuantity();
  1377.     }
  1379.     /**
  1380.      * Get fingerprint by 'shippingTotal' key
  1381.      *
  1382.      * @return float
  1383.      */
  1384.     protected function getFingerprintByShippingTotal()
  1385.     {
  1386.         /** @var \XLite\Logic\Order\Modifier\Shipping $shippingModifier */
  1387.         $shippingModifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  1389.         if (!$shippingModifier) {
  1390.             return 0;
  1391.         }
  1393.         $rate = $shippingModifier->getSelectedRate();
  1395.         return $rate ? (float)$rate->getTotalRate() : 0;
  1396.     }
  1398.     /**
  1399.      * Get fingerprint by 'total' key
  1400.      *
  1401.      * @return float
  1402.      */
  1403.     protected function getFingerprintByTotal()
  1404.     {
  1405.         return (float) $this->getTotal();
  1406.     }
  1408.     /**
  1409.      * Get fingerprint by 'freeShippingNote' key
  1410.      *
  1411.      * @return bool
  1412.      */
  1413.     protected function getFingerPrintByFreeShippingNote()
  1414.     {
  1415.         return $this->showFreeShippingNote();
  1416.     }
  1418.     /**
  1419.      * Get fingerprint by 'shippingMethodId' key
  1420.      *
  1421.      * @return integer
  1422.      */
  1423.     protected function getFingerprintByShippingMethodId()
  1424.     {
  1425.         /** @var \XLite\Logic\Order\Modifier\Shipping $shippingModifier */
  1426.         $shippingModifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  1428.         if (!$shippingModifier) {
  1429.             return 0;
  1430.         }
  1432.         $rate = $shippingModifier->getSelectedRate();
  1434.         return $rate ? $rate->getMethod()->getMethodId() : 0;
  1435.     }
  1437.     /**
  1438.      * Get fingerprint by 'paymentMethodId' key
  1439.      *
  1440.      * @return integer
  1441.      */
  1442.     protected function getFingerprintByPaymentMethodId()
  1443.     {
  1444.         return $this->getPaymentMethod()
  1445.                 ? $this->getPaymentMethod()->getMethodId()
  1446.                 : 0;
  1447.     }
  1449.     /**
  1450.      * Get fingerprint by 'shippingMethodsHash' key
  1451.      *
  1452.      * @return string
  1453.      */
  1454.     protected function getFingerprintByShippingMethodsHash()
  1455.     {
  1456.         /** @var \XLite\Logic\Order\Modifier\Shipping $shippingModifier */
  1457.         $shippingModifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  1458.         $shippingMethodsHash = [];
  1459.         if ($shippingModifier) {
  1460.             $rates = $shippingModifier->getRates();
  1461.             foreach ($rates as $rate) {
  1462.                 $methodId = $rate->getMethod()->getMethodId();
  1463.                 $totalRate = $rate->getTotalRate();
  1464.                 $shippingMethodsHash[] = "$methodId:$totalRate";
  1465.             }
  1466.         }
  1468.         return implode(';', $shippingMethodsHash);
  1469.     }
  1471.     /**
  1472.      * Get fingerprint by 'paymentMethodsHash' key
  1473.      *
  1474.      * @return string
  1475.      */
  1476.     protected function getFingerprintByPaymentMethodsHash()
  1477.     {
  1478.         $paymentMethodsHash = [];
  1479.         foreach ($this->getPaymentMethods() as $method) {
  1480.             $paymentMethodsHash[] = $method->getMethodId();
  1481.         }
  1483.         return implode(';', $paymentMethodsHash);
  1484.     }
  1486.     /**
  1487.      * Get fingerprint by 'shippingAddressId' key
  1488.      *
  1489.      * @return integer
  1490.      */
  1491.     protected function getFingerprintByShippingAddressId()
  1492.     {
  1493.         return $this->getProfile() && $this->getProfile()->getShippingAddress()
  1494.             ? $this->getProfile()->getShippingAddress()->getAddressId()
  1495.             : 0;
  1496.     }
  1498.     /**
  1499.      * Get fingerprint by 'billingAddressId' key
  1500.      *
  1501.      * @return integer
  1502.      */
  1503.     protected function getFingerprintByBillingAddressId()
  1504.     {
  1505.         return $this->getProfile() && $this->getProfile()->getBillingAddress()
  1506.             ? $this->getProfile()->getBillingAddress()->getAddressId()
  1507.             : 0;
  1508.     }
  1510.     /**
  1511.      * @return array
  1512.      */
  1513.     protected function getFingerprintByShippingAddressFields()
  1514.     {
  1515.         if ($this->getProfile() && $this->getProfile()->getShippingAddress()) {
  1516.             return $this->getProfile()->getShippingAddress()->serialize();
  1517.         }
  1519.         return [];
  1520.     }
  1522.     /**
  1523.      * @return array
  1524.      */
  1525.     protected function getFingerprintByBillingAddressFields()
  1526.     {
  1527.         if ($this->getProfile() && $this->getProfile()->getBillingAddress()) {
  1528.             return $this->getProfile()->getBillingAddress()->serialize();
  1529.         }
  1531.         return [];
  1532.     }
  1535.     /**
  1536.      * Get fingerprint by 'sameAddress' key
  1537.      *
  1538.      * @return boolean
  1539.      */
  1540.     protected function getFingerprintBySameAddress()
  1541.     {
  1542.         return $this->getProfile() && $this->getProfile()->isSameAddress();
  1543.     }
  1545.     /**
  1546.      * Get detail
  1547.      *
  1548.      * @param string $name Details cell name
  1549.      *
  1550.      * @return mixed
  1551.      */
  1552.     public function getDetail($name)
  1553.     {
  1554.         $details = $this->getDetails();
  1555.         return \Includes\Utils\ArrayManager::findValue(
  1556.             $details,
  1557.             [$this, 'checkDetailName'],
  1558.             $name
  1559.         );
  1560.     }
  1562.     /**
  1563.      * Get detail value
  1564.      *
  1565.      * @param string $name Details cell name
  1566.      *
  1567.      * @return mixed
  1568.      */
  1569.     public function getDetailValue($name)
  1570.     {
  1571.         $detail = $this->getDetail($name);
  1573.         return $detail ? $detail->getValue() : null;
  1574.     }
  1576.     /**
  1577.      * Set detail cell
  1578.      * To unset detail cell the value should be null
  1579.      *
  1580.      * @param string $name  Cell code
  1581.      * @param mixed  $value Cell value
  1582.      * @param string $label Cell label OPTIONAL
  1583.      *
  1584.      * @return void
  1585.      */
  1586.     public function setDetail($name, $value, $label = null)
  1587.     {
  1588.         $detail = $this->getDetail($name);
  1590.         if ($value === null) {
  1591.             if ($detail) {
  1592.                 $this->getDetails()->removeElement($detail);
  1593.                 \XLite\Core\Database::getEM()->remove($detail);
  1594.             }
  1595.         } else {
  1596.             if (!$detail) {
  1597.                 $detail = new \XLite\Model\OrderDetail();
  1599.                 $detail->setOrder($this);
  1600.                 $this->addDetails($detail);
  1602.                 $detail->setName($name);
  1603.             }
  1605.             $detail->setValue($value);
  1606.             $detail->setLabel($label);
  1607.         }
  1608.     }
  1610.     /**
  1611.      * Get meaning order details
  1612.      *
  1613.      * @return array
  1614.      */
  1615.     public function getMeaningDetails()
  1616.     {
  1617.         $result = [];
  1619.         foreach ($this->getDetails() as $detail) {
  1620.             if ($detail->getLabel()) {
  1621.                 $result[] = $detail;
  1622.             }
  1623.         }
  1625.         return $result;
  1626.     }
  1628.     /**
  1629.      * Called when an order successfully placed by a client
  1630.      *
  1631.      * @throws \Doctrine\ORM\NoResultException
  1632.      * @throws \Doctrine\ORM\NonUniqueResultException
  1633.      */
  1634.     public function processSucceed()
  1635.     {
  1636.         $this->markAsOrder();
  1638.         if ($this->canChangeStatusOnSucceed()) {
  1639.             $this->setShippingStatus(\XLite\Model\Order\Status\Shipping::STATUS_NEW);
  1640.         }
  1643.         $property = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\Property')->findOneBy([
  1644.             'paymentStatus'  => $this->getPaymentStatus(),
  1645.             'shippingStatus' => $this->getShippingStatus(),
  1646.         ]);
  1648.         $incStock = $property ? $property->getIncStock() : null;
  1649.         if ($incStock === false) {
  1650.             $this->processBackorderedItems();
  1651.             $this->decreaseInventory();
  1652.             $this->setStockStatus('reduced');
  1653.         }
  1655.         // Register 'Place order' event in the order history
  1656.         $this->registerPlaceOrder();
  1658.         // Transform attributes
  1659.         $this->transformItemsAttributes();
  1661.         $this->sendOrderCreatedIfNeeded();
  1663.         $this->sendOrderWaitingForApproveIfNeeded();
  1664.     }
  1666.     /**
  1667.      * @return int
  1668.      * @throws \Doctrine\ORM\NoResultException
  1669.      * @throws \Doctrine\ORM\NonUniqueResultException
  1670.      */
  1671.     protected function processBackorderedItems()
  1672.     {
  1673.         $backstockCount = 0;
  1675.         $items = $this->getItems();
  1677.         foreach ($items as $item) {
  1678.             if ($item->isDeleted() || !$this->isInventoryEnabledForItem($item)) {
  1679.                 continue;
  1680.             }
  1681.             \XLite\Core\Database::getEM()->transactional(function (EntityManager $em) use ($item, &$backstockCount) {
  1682.                 $product = $item->getProduct();
  1683.                 $em->lock($item->getProduct(), LockMode::PESSIMISTIC_READ);
  1684.                 $em->refresh($product);
  1686.                 $pa = $this->getProductAmountForItem($item);
  1687.                 $this->reduceProductAmountForItem($item);
  1688.                 $ia = $item->getAmount();
  1689.                 if ($pa < $ia) {
  1690.                     $backstockCount += $ia - $pa;
  1691.                     $item->setBackorderedAmount($ia - $pa);
  1692.                 }
  1693.             });
  1694.         }
  1696.         if ($backstockCount) {
  1697.             \XLite\Core\Mailer::sendBackorderCreatedAdmin($this);
  1698.             $this->setShippingStatus(\XLite\Model\Order\Status\Shipping::STATUS_NEW_BACKORDERED);
  1699.             //Set oldShippingStatus to NBA
  1700.             $this->setShippingStatus(\XLite\Model\Order\Status\Shipping::STATUS_NEW_BACKORDERED);
  1701.             $this->assignBackorderCompetitors();
  1702.         }
  1704.         return $backstockCount;
  1705.     }
  1707.     /**
  1708.      * @throws \Doctrine\ORM\NoResultException
  1709.      * @throws \Doctrine\ORM\NonUniqueResultException
  1710.      */
  1711.     protected function assignBackorderCompetitors()
  1712.     {
  1713.         $repo = Database::getRepo('XLite\Model\Order');
  1714.         $competitors = $this->getBackorderCompetitors();
  1715.         foreach ($this->getItems() as $item) {
  1716.             if (
  1717.                 $item->getBackorderedAmount()
  1718.                 && $competitor = $repo->getBackorderCompetitorByItem($item)
  1719.             ) {
  1720.                 if (!$competitors->contains($competitor)) {
  1721.                     $this->getBackorderCompetitors()->add($competitor);
  1722.                 }
  1723.             }
  1724.         }
  1725.     }
  1727.     /**
  1728.      * @return bool
  1729.      */
  1730.     public function isBackordered()
  1731.     {
  1732.         return $this->getShippingStatusCode() === \XLite\Model\Order\Status\Shipping::STATUS_NEW_BACKORDERED;
  1733.     }
  1735.     /**
  1736.      * @param OrderItem $item
  1737.      *
  1738.      * @return int
  1739.      */
  1740.     protected function getProductAmountForItem(OrderItem $item)
  1741.     {
  1742.         $key = $this->getProductKeyForItem($item);
  1744.         if (!isset($this->backorderProductAmounts[$key])) {
  1745.             $this->backorderProductAmounts[$key] = $this->calculateProductAmountForItem($item);
  1746.         }
  1748.         return $this->backorderProductAmounts[$key];
  1749.     }
  1751.     /**
  1752.      * @param OrderItem $item
  1753.      *
  1754.      * @return int
  1755.      */
  1756.     protected function calculateProductAmountForItem(OrderItem $item)
  1757.     {
  1758.         return $item->getProduct()->getAmount();
  1759.     }
  1761.     /**
  1762.      * @param OrderItem $item
  1763.      *
  1764.      * @return static
  1765.      */
  1766.     protected function reduceProductAmountForItem(OrderItem $item)
  1767.     {
  1768.         $this->backorderProductAmounts[$this->getProductKeyForItem($item)]
  1769.             = max($this->getProductAmountForItem($item) - $item->getAmount(), 0);
  1771.         return $this;
  1772.     }
  1774.     /**
  1775.      * @param OrderItem $item
  1776.      *
  1777.      * @return boolean
  1778.      */
  1779.     protected function isInventoryEnabledForItem(OrderItem $item)
  1780.     {
  1781.         return $item->getProduct()->getInventoryEnabled();
  1782.     }
  1784.     /**
  1785.      * @param OrderItem $item
  1786.      *
  1787.      * @return string
  1788.      */
  1789.     protected function getProductKeyForItem(OrderItem $item)
  1790.     {
  1791.         return $item->getProduct()->getId();
  1792.     }
  1794.     protected function registerPlaceOrder()
  1795.     {
  1796.         \XLite\Core\OrderHistory::getInstance()->registerPlaceOrder($this->getOrderId());
  1797.     }
  1799.     /**
  1800.      * Send order created notification if needed
  1801.      */
  1802.     public function sendOrderCreatedIfNeeded()
  1803.     {
  1804.         if (
  1805.             $this->getPaymentStatus()
  1806.             && in_array(
  1807.                 $this->getPaymentStatus()->getCode(),
  1808.                 $this->getValidStatusesForCreateNotification(),
  1809.                 true
  1810.             )
  1811.         ) {
  1812.             \XLite\Core\Mailer::sendOrderCreated($this);
  1813.         }
  1814.     }
  1816.     /**
  1817.      * Send order awaiting approval notification if needed
  1818.      */
  1819.     public function sendOrderWaitingForApproveIfNeeded()
  1820.     {
  1821.         if (
  1822.             $this->getShippingStatus()
  1823.             && $this->getShippingStatus()->getCode() === \XLite\Model\Order\Status\Shipping::STATUS_WAITING_FOR_APPROVE
  1824.         ) {
  1825.             \XLite\Core\Mailer::sendOrderWaitingForApprove($this);
  1826.         }
  1827.     }
  1829.     /**
  1830.      * Valid not paid statuses
  1831.      *
  1832.      * @return array
  1833.      */
  1834.     public function getValidStatusesForCreateNotification()
  1835.     {
  1836.         return [
  1837.             \XLite\Model\Order\Status\Payment::STATUS_QUEUED,
  1838.             \XLite\Model\Order\Status\Payment::STATUS_AUTHORIZED,
  1839.         ];
  1840.     }
  1842.     /**
  1843.      * Mark cart as order
  1844.      *
  1845.      * @return void
  1846.      */
  1847.     public function markAsOrder()
  1848.     {
  1849.     }
  1851.     /**
  1852.      * Mark order as cart
  1853.      *
  1854.      * @return void
  1855.      */
  1856.     public function markAsCart()
  1857.     {
  1858.         $this->getRepository()->markAsCart($this->getOrderId());
  1859.     }
  1861.     /**
  1862.      * Refresh order items
  1863.      * TODO - rework after tax subsystem rework
  1864.      *
  1865.      * @return void
  1866.      */
  1867.     public function refreshItems()
  1868.     {
  1869.     }
  1871.     /**
  1872.      * Return removing status
  1873.      *
  1874.      * @return boolean
  1875.      */
  1876.     public function isRemoving()
  1877.     {
  1878.         return $this->isRemoving;
  1879.     }
  1881.     /**
  1882.      * Constructor
  1883.      *
  1884.      * @param array $data Entity properties OPTIONAL
  1885.      */
  1886.     public function __construct(array $data = [])
  1887.     {
  1888.         $this->details              = new ArrayCollection();
  1889.         $this->items                = new ArrayCollection();
  1890.         $this->surcharges           = new ArrayCollection();
  1891.         $this->payment_transactions = new ArrayCollection();
  1892.         $this->events               = new ArrayCollection();
  1893.         $this->trackingNumbers      = new ArrayCollection();
  1894.         $this->backorderCompetitors = new ArrayCollection();
  1896.         parent::__construct($data);
  1897.     }
  1899.     /**
  1900.      * Return list of available payment methods
  1901.      *
  1902.      * @return array
  1903.      */
  1904.     public function getPaymentMethods()
  1905.     {
  1906.         if (0 >= $this->getOpenTotal()) {
  1907.             return [];
  1908.         }
  1910.         $list = \XLite\Core\Database::getRepo('XLite\Model\Payment\Method')
  1911.             ->findAllActive();
  1913.         foreach ($list as $i => $method) {
  1914.             if (!$method->isEnabled() || !$method->getProcessor()->isApplicable($this, $method)) {
  1915.                 unset($list[$i]);
  1916.             }
  1917.         }
  1919.         if (\XLite\Core\Auth::getInstance()->isOperatingAsUserMode()) {
  1920.             $fakeMethods = \XLite\Core\Auth::getInstance()->getOperateAsUserPaymentMethods();
  1922.             $filteredFakeMethods = array_filter(
  1923.                 $fakeMethods,
  1924.                 static function ($fakeMethod) use ($list) {
  1925.                     $fakeServiceName = $fakeMethod->getServiceName();
  1927.                     // Check if $list already contains fake method
  1928.                     return !array_reduce($list, static function ($carry, $method) use ($fakeServiceName) {
  1929.                         return $carry ?: $method->getServiceName() === $fakeServiceName;
  1930.                     }, false);
  1931.                 }
  1932.             );
  1934.             $list = array_merge(
  1935.                 $list,
  1936.                 $filteredFakeMethods
  1937.             );
  1938.         }
  1940.         return $list;
  1941.     }
  1943.     /**
  1944.      * Renew payment method
  1945.      *
  1946.      * @return void
  1947.      */
  1948.     public function renewPaymentMethod()
  1949.     {
  1950.         if ($this->isPaymentMethodRequired()) {
  1951.             $method = $this->getPaymentMethod();
  1953.             if ($this->isPaymentMethodIsApplicable($method)) {
  1954.                 $this->setPaymentMethod($method);
  1955.             } else {
  1956.                 $first = $this->getFirstPaymentMethod();
  1957.                 if ($first) {
  1958.                     if ($this->getProfile()) {
  1959.                         $this->getProfile()->setLastPaymentId($first->getMethodId());
  1960.                     }
  1962.                     $this->setPaymentMethod($first);
  1963.                 } else {
  1964.                     $this->unsetPaymentMethod();
  1965.                 }
  1966.             }
  1967.         } else {
  1968.             $this->unsetPaymentMethod();
  1969.         }
  1970.     }
  1972.     /**
  1973.      * Returns true if order is allowed to change status on succeed
  1974.      *
  1975.      * @return boolean
  1976.      */
  1977.     protected function canChangeStatusOnSucceed()
  1978.     {
  1979.         return $this->getShippingStatus() === null;
  1980.     }
  1982.     /**
  1983.      * Return true if payment method is required for the order
  1984.      *
  1985.      * @return boolean
  1986.      */
  1987.     protected function isPaymentMethodRequired()
  1988.     {
  1989.         return 0 < $this->getOpenTotal()
  1990.             && ($this instanceof \XLite\Model\Cart || $this->getOrderNumber() === null);
  1991.     }
  1993.     /**
  1994.      * Check if given payment method can be applied to the order
  1995.      *
  1996.      * @param  \XLite\Model\Payment\Method  $method
  1997.      * @return boolean
  1998.      */
  1999.     protected function isPaymentMethodIsApplicable($method)
  2000.     {
  2001.         return $method
  2002.             && $method->getProcessor()
  2003.             && $method->getProcessor()->isApplicable($this, $method);
  2004.     }
  2006.     /**
  2007.      * Get payment method
  2008.      *
  2009.      * @return \XLite\Model\Payment\Method|null
  2010.      */
  2011.     public function getPaymentMethod()
  2012.     {
  2013.         $transaction = $this->getFirstOpenPaymentTransaction();
  2014.         if (!$transaction) {
  2015.             $transaction = $this->hasUnpaidTotal() || count($this->getPaymentTransactions()) === 0
  2016.                 ? $this->assignLastPaymentMethod()
  2017.                 : $this->getPaymentTransactions()->last();
  2018.         }
  2020.         return $transaction ? $transaction->getPaymentMethod() : null;
  2021.     }
  2023.     /**
  2024.      * Check item key equal
  2025.      *
  2026.      * @param \XLite\Model\OrderItem $item Item
  2027.      * @param string                 $key  Key
  2028.      *
  2029.      * @return boolean
  2030.      */
  2031.     public function checkItemKeyEqual(\XLite\Model\OrderItem $item, $key)
  2032.     {
  2033.         return $item->getKey() == $key;
  2034.     }
  2036.     /**
  2037.      * Check item id equal
  2038.      *
  2039.      * @param \XLite\Model\OrderItem $item   Item
  2040.      * @param integer                $itemId Item id
  2041.      *
  2042.      * @return boolean
  2043.      */
  2044.     public function checkItemIdEqual(\XLite\Model\OrderItem $item, $itemId)
  2045.     {
  2046.         return $item->getItemId() == $itemId;
  2047.     }
  2049.     /**
  2050.      * Check order detail name
  2051.      *
  2052.      * @param \XLite\Model\OrderDetail $detail Detail
  2053.      * @param string                   $name   Name
  2054.      *
  2055.      * @return boolean
  2056.      */
  2057.     public function checkDetailName(\XLite\Model\OrderDetail $detail, $name)
  2058.     {
  2059.         return $detail->getName() === $name;
  2060.     }
  2062.     /**
  2063.      * Check payment transaction status
  2064.      *
  2065.      * @param \XLite\Model\Payment\Transaction $transaction Transaction
  2066.      * @param mixed                            $status      Status
  2067.      *
  2068.      * @return boolean
  2069.      */
  2070.     public function checkPaymentTransactionStatusEqual(\XLite\Model\Payment\Transaction $transaction, $status)
  2071.     {
  2072.         return is_array($status)
  2073.             ? in_array($transaction->getStatus(), $status, true)
  2074.             : $transaction->getStatus() === $status;
  2075.     }
  2077.     /**
  2078.      * Check payment transaction - open or not
  2079.      *
  2080.      * @param \XLite\Model\Payment\Transaction $transaction Payment transaction
  2081.      *
  2082.      * @return boolean
  2083.      */
  2084.     public function checkPaymentTransactionOpen(\XLite\Model\Payment\Transaction $transaction)
  2085.     {
  2086.         return $transaction->isOpen() || $transaction->isInProgress();
  2087.     }
  2089.     /**
  2090.      * Check - is item product id equal specified product id
  2091.      *
  2092.      * @param \XLite\Model\OrderItem $item      Item
  2093.      * @param integer                $productId Product id
  2094.      *
  2095.      * @return boolean
  2096.      */
  2097.     public function isItemProductIdEqual(\XLite\Model\OrderItem $item, $productId)
  2098.     {
  2099.         return $item->getProductId() == $productId;
  2100.     }
  2102.     /**
  2103.      * Check last payment method
  2104.      *
  2105.      * @param \XLite\Model\Payment\Method $pmethod       Payment method
  2106.      * @param integer                     $lastPaymentId Last selected payment method id
  2107.      *
  2108.      * @return boolean
  2109.      */
  2110.     public function checkLastPaymentMethod(\XLite\Model\Payment\Method $pmethod, $lastPaymentId)
  2111.     {
  2112.         $result = $pmethod->getMethodId() == $lastPaymentId;
  2113.         if ($result) {
  2114.             $this->setPaymentMethod($pmethod);
  2116.             \XLite\Core\Database::getEM()->flush();
  2117.         }
  2119.         return $result;
  2120.     }
  2122.     // {{{ Payment method and transactions
  2124.     /**
  2125.      * Set payment method
  2126.      *
  2127.      * @param \XLite\Model\Payment\Method|null $paymentMethod Payment method
  2128.      * @param float                            $value         Payment transaction value OPTIONAL
  2129.      *
  2130.      * @return void
  2131.      */
  2132.     public function setPaymentMethod($paymentMethod, $value = null)
  2133.     {
  2134.         if ($paymentMethod && !($paymentMethod instanceof \XLite\Model\Payment\Method)) {
  2135.             $paymentMethod = null;
  2136.         }
  2138.         $sameMethod = false;
  2140.         if ($paymentMethod === null || $this->getFirstOpenPaymentTransaction()) {
  2141.             $transaction = $this->getFirstOpenPaymentTransaction();
  2142.             if ($transaction) {
  2143.                 if ($paymentMethod === null) {
  2144.                     $this->unsetPaymentMethod();
  2145.                 } elseif ($transaction->isSameMethod($paymentMethod)) {
  2146.                     $transaction->updateValue($this);
  2147.                     $sameMethod = true;
  2148.                 }
  2149.             }
  2150.         }
  2152.         if ($paymentMethod === null) {
  2153.             $this->setPaymentMethodName('');
  2154.         } elseif (!$sameMethod) {
  2155.             $this->unsetPaymentMethod();
  2156.             $this->addPaymentTransaction($paymentMethod, $value);
  2157.             $this->setPaymentMethodName($paymentMethod->getName());
  2158.         }
  2159.     }
  2161.     /**
  2162.      * Unset payment method
  2163.      *
  2164.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  2165.      *
  2166.      * @return void
  2167.      */
  2168.     public function unsetPaymentMethod()
  2169.     {
  2170.         $transaction = $this->getFirstOpenPaymentTransaction();
  2172.         $this->setPaymentMethodName('');
  2174.         if ($transaction) {
  2175.             $this->payment_transactions->removeElement($transaction);
  2176.             \XLite\Core\Database::getEM()->remove($transaction);
  2177.         }
  2178.     }
  2180.     /**
  2181.      * Get active payment transactions
  2182.      *
  2183.      * @return array
  2184.      */
  2185.     public function getActivePaymentTransactions()
  2186.     {
  2187.         $result = [];
  2188.         foreach ($this->getPaymentTransactions() as $t) {
  2189.             if ($t->isCompleted() || $t->isPending()) {
  2190.                 $result[] = $t;
  2191.             }
  2192.         }
  2194.         return $result;
  2195.     }
  2197.     /**
  2198.      * Get visible payment methods
  2199.      *
  2200.      * @return array
  2201.      */
  2202.     public function getVisiblePaymentMethods()
  2203.     {
  2204.         $result = [];
  2206.         foreach ($this->getActivePaymentTransactions() as $t) {
  2207.             if ($t->getPaymentMethod()) {
  2208.                 $result[] = $t->getPaymentMethod();
  2209.             }
  2210.         }
  2212.         if (count($result) === 0 && 0 < count($this->getPaymentTransactions())) {
  2213.             $method = $this->getPaymentTransactions()->last()->getPaymentMethod();
  2214.             if ($method) {
  2215.                 $result[] = $method;
  2216.             }
  2217.         }
  2219.         return $result;
  2220.     }
  2222.     /**
  2223.      * Get first open (not payed) payment transaction
  2224.      *
  2225.      * @return \XLite\Model\Payment\Transaction|null
  2226.      */
  2227.     public function getFirstOpenPaymentTransaction()
  2228.     {
  2229.         $transactions = $this->getPaymentTransactions();
  2231.         return \Includes\Utils\ArrayManager::findValue(
  2232.             $transactions,
  2233.             [$this, 'checkPaymentTransactionOpen']
  2234.         );
  2235.     }
  2237.     /**
  2238.      * Get open (not-payed) total
  2239.      *
  2240.      * @return float
  2241.      */
  2242.     public function getOpenTotal()
  2243.     {
  2244.         $total = $this->getCurrency()->roundValue($this->getTotal());
  2245.         $totalAsSurcharges = $this->getCurrency()->roundValue($this->getSurchargesTotal());
  2247.         $totalsPaid = $this->getPaidTotals();
  2249.         return max(
  2250.             $total - $totalsPaid['total'],
  2251.             $totalAsSurcharges - $totalsPaid['totalAsSurcharges']
  2252.         );
  2253.     }
  2255.     public function getPaidTotals()
  2256.     {
  2257.         $total = $totalAsSurcharges = 0;
  2259.         foreach ($this->getPaymentTransactions() as $t) {
  2260.             $total += $this->getCurrency()->roundValue($t->getChargeValueModifier());
  2261.             $totalAsSurcharges += $this->getCurrency()->roundValue($t->getChargeValueModifier());
  2262.         }
  2264.         return [
  2265.             'total'             => $total,
  2266.             'totalAsSurcharges' => $totalAsSurcharges,
  2267.         ];
  2268.     }
  2270.     /**
  2271.      * Get paid total
  2272.      *
  2273.      * @return float
  2274.      */
  2275.     public function getPaidTotal()
  2276.     {
  2277.         $totals = $this->getPaidTotals();
  2279.         return max(
  2280.             $totals['total'],
  2281.             $totals['totalAsSurcharges']
  2282.         );
  2283.     }
  2285.     /**
  2286.      * Check - order is open (has initialized transactions and has open total) or not
  2287.      *
  2288.      * @return boolean
  2289.      */
  2290.     public function isOpen()
  2291.     {
  2292.         return $this->getFirstOpenPaymentTransaction() && $this->hasUnpaidTotal();
  2293.     }
  2295.     /**
  2296.      * Has unpaid total?
  2297.      *
  2298.      * @return boolean
  2299.      */
  2300.     public function hasUnpaidTotal()
  2301.     {
  2302.         return $this->getCurrency()->getMinimumValue() <= $this->getCurrency()->roundValue(abs($this->getOpenTotal()));
  2303.     }
  2305.     /**
  2306.      * Get totally payed total
  2307.      *
  2308.      * @return float
  2309.      */
  2310.     public function getPayedTotal()
  2311.     {
  2312.         $total = $this->getCurrency()->roundValue($this->getTotal());
  2314.         foreach ($this->getPaymentTransactions() as $t) {
  2315.             if ($t->isCompleted() && ($t->isAuthorized() || $t->isCaptured())) {
  2316.                 $total -= $this->getCurrency()->roundValue($t->getChargeValueModifier());
  2317.             }
  2318.         }
  2320.         $sums = $this->getRawPaymentTransactionSums();
  2321.         $total += $sums['refunded'];
  2323.         return $total;
  2324.     }
  2326.     /**
  2327.      * Check - order is payed or not
  2328.      * Payed - order has not open total and all payment transactions are failed or completed
  2329.      *
  2330.      * @return boolean
  2331.      */
  2332.     public function isPayed()
  2333.     {
  2334.         return 0 >= $this->getPayedTotal();
  2335.     }
  2337.     /**
  2338.      * Check - order has in-progress payments or not
  2339.      *
  2340.      * @return boolean
  2341.      */
  2342.     public function hasInprogressPayments()
  2343.     {
  2344.         $result = false;
  2346.         foreach ($this->getPaymentTransactions() as $t) {
  2347.             if ($t->isInProgress()) {
  2348.                 $result = true;
  2349.                 break;
  2350.             }
  2351.         }
  2353.         return $result;
  2354.     }
  2356.     /**
  2357.      * Assign last used payment method
  2358.      *
  2359.      * @return \XLite\Model\Payment\Transaction|void
  2360.      */
  2361.     protected function assignLastPaymentMethod()
  2362.     {
  2363.         $found = null;
  2365.         if ($this->isPaymentMethodRequired() && $this->getProfile() && $this->getProfile()->getLastPaymentId()) {
  2366.             $paymentMethods = $this->getPaymentMethods();
  2367.             $found = \Includes\Utils\ArrayManager::findValue(
  2368.                 $paymentMethods,
  2369.                 [$this, 'checkLastPaymentMethod'],
  2370.                 $this->getProfile()->getLastPaymentId()
  2371.             );
  2372.         }
  2374.         return $found ? $this->getFirstOpenPaymentTransaction() : null;
  2375.     }
  2377.     /**
  2378.      * Get first applicable payment method
  2379.      *
  2380.      * @return \XLite\Model\Payment\Method
  2381.      */
  2382.     protected function getFirstPaymentMethod()
  2383.     {
  2384.         $list = $this->getPaymentMethods();
  2386.         return $list ? array_shift($list) : null;
  2387.     }
  2389.     /**
  2390.      * Add payment transaction
  2391.      * FIXME: move logic into \XLite\Model\Payment\Transaction
  2392.      *
  2393.      * @param \XLite\Model\Payment\Method $method Payment method
  2394.      * @param float                       $value  Value OPTIONAL
  2395.      *
  2396.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  2397.      *
  2398.      * @return void
  2399.      */
  2400.     protected function addPaymentTransaction(\XLite\Model\Payment\Method $method, $value = null)
  2401.     {
  2402.         if ($value === null || 0 >= $value) {
  2403.             $value = $this->getOpenTotal();
  2404.         } else {
  2405.             $value = min($value, $this->getOpenTotal());
  2406.         }
  2408.         // Do not add 0 or <0 transactions. This is for a "Payment not required" case.
  2409.         if ($value > 0) {
  2410.             $transaction = new \XLite\Model\Payment\Transaction();
  2412.             $this->addPaymentTransactions($transaction);
  2413.             $transaction->setOrder($this);
  2415.             $transaction->setPaymentMethod($method);
  2417.             \XLite\Core\Database::getEM()->persist($method);
  2419.             $transaction->setCurrency($this->getCurrency());
  2421.             $transaction->setStatus($transaction::STATUS_INITIALIZED);
  2422.             $transaction->setValue($value);
  2423.             $transaction->setType($method->getProcessor()->getInitialTransactionType($method));
  2425.             if ($method->getProcessor()->isTestMode($method)) {
  2426.                 $transaction->setDataCell(
  2427.                     'test_mode',
  2428.                     true,
  2429.                     'Test mode'
  2430.                 );
  2431.             }
  2433.             \XLite\Core\Database::getEM()->persist($transaction);
  2434.         }
  2435.     }
  2437.     // }}}
  2439.     // {{{ Shipping
  2441.     /**
  2442.      * Returns last shipping method id
  2443.      *
  2444.      * @return integer|null
  2445.      */
  2446.     public function getLastShippingId()
  2447.     {
  2448.         /** @var \XLite\Model\Profile $profile */
  2449.         $profile = $this->getProfile();
  2451.         return $profile ? $profile->getLastShippingId() : null;
  2452.     }
  2454.     /**
  2455.      * Sets last shipping method id used
  2456.      *
  2457.      * @param integer $value Method id
  2458.      *
  2459.      * @return void
  2460.      */
  2461.     public function setLastShippingId($value)
  2462.     {
  2463.         /** @var \XLite\Model\Profile $profile */
  2464.         $profile = $this->getProfile();
  2466.         if ($profile !== null) {
  2467.             $profile->setLastShippingId($value);
  2468.         }
  2469.     }
  2471.     /**
  2472.      * Renew shipping method
  2473.      *
  2474.      * @return void
  2475.      */
  2476.     public function renewShippingMethod()
  2477.     {
  2478.         if (!\XLite\Model\Shipping::getInstance()->shouldAllowLongCalculations()) {
  2479.             return;
  2480.         }
  2482.         $this->updateEmptyShippingID();
  2484.         /** @var \XLite\Logic\Order\Modifier\Shipping $modifier */
  2485.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  2486.         if ($modifier && $modifier->getSelectedRate() === null) {
  2487.             $method = $this->getFirstShippingMethod();
  2489.             if ($method) {
  2490.                 $methodId = $method->getMethodId();
  2492.                 $this->setLastShippingId($methodId);
  2493.                 $this->setShippingId($methodId);
  2494.             } else {
  2495.                 $this->setShippingId(0);
  2496.             }
  2497.         }
  2498.     }
  2500.     /**
  2501.      * Get the link for the detailed tracking information
  2502.      *
  2503.      * @return boolean|\XLite\Model\Shipping\Processor\AProcessor False if the shipping is not set or
  2504.      *                                                            shipping processor is absent
  2505.      */
  2506.     public function getShippingProcessor()
  2507.     {
  2508.         if ($this->shippingProcessor === null) {
  2509.             $shipping = \XLite\Core\Database::getRepo('XLite\Model\Shipping\Method')->find($this->getShippingId());
  2510.             $this->shippingProcessor = $shipping && $shipping->getProcessorObject()
  2511.                 ? $shipping->getProcessorObject()
  2512.                 : false;
  2513.         }
  2515.         return $this->shippingProcessor;
  2516.     }
  2518.     /**
  2519.      * Defines whether the form must be used for tracking information.
  2520.      * The 'getTrackingInformationURL' result will be used as tracking link instead
  2521.      *
  2522.      * @param string $trackingNumber Tracking number value
  2523.      *
  2524.      * @return boolean
  2525.      */
  2526.     public function isTrackingInformationForm($trackingNumber)
  2527.     {
  2528.         return $this->getShippingProcessor()
  2529.             ? $this->getShippingProcessor()->isTrackingInformationForm($trackingNumber)
  2530.             : null;
  2531.     }
  2533.     /**
  2534.      * Get the link for the detailed tracking information
  2535.      *
  2536.      * @param string $trackingNumber Tracking number value
  2537.      *
  2538.      * @return null|string
  2539.      */
  2540.     public function getTrackingInformationURL($trackingNumber)
  2541.     {
  2542.         return $this->getShippingProcessor()
  2543.             ? $this->getShippingProcessor()->getTrackingInformationURL($trackingNumber)
  2544.             : null;
  2545.     }
  2547.     /**
  2548.      * Get the form parameters for the detailed tracking information
  2549.      *
  2550.      * @param string $trackingNumber Tracking number value
  2551.      *
  2552.      * @return null|array
  2553.      */
  2554.     public function getTrackingInformationParams($trackingNumber)
  2555.     {
  2556.         return $this->getShippingProcessor()
  2557.             ? $this->getShippingProcessor()->getTrackingInformationParams($trackingNumber)
  2558.             : null;
  2559.     }
  2561.     /**
  2562.      * Get the form method for the detailed tracking information
  2563.      *
  2564.      * @param string $trackingNumber Tracking number value
  2565.      *
  2566.      * @return null|string
  2567.      */
  2568.     public function getTrackingInformationMethod($trackingNumber)
  2569.     {
  2570.         return $this->getShippingProcessor()
  2571.             ? $this->getShippingProcessor()->getTrackingInformationMethod($trackingNumber)
  2572.             : null;
  2573.     }
  2575.     /**
  2576.      * Get first shipping method
  2577.      *
  2578.      * @return \XLite\Model\Shipping\Method
  2579.      */
  2580.     protected function getFirstShippingMethod()
  2581.     {
  2582.         $method = null;
  2584.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  2585.         if ($modifier) {
  2586.             $rates = $modifier->getRates();
  2587.             $rate = array_shift($rates);
  2588.             if ($rate) {
  2589.                 $method = $rate->getMethod();
  2590.             }
  2591.         }
  2593.         return $method;
  2594.     }
  2596.     // }}}
  2598.     // {{{ Mail notification
  2600.     /**
  2601.      * Set value of isNotificationSent flag and return old value
  2602.      *
  2603.      * @param boolean $value New value
  2604.      *
  2605.      * @return boolean
  2606.      */
  2607.     public function setIsNotificationSent($value)
  2608.     {
  2609.         $oldValue = $this->isNotificationSent;
  2610.         $this->isNotificationSent = $value;
  2612.         return $oldValue;
  2613.     }
  2615.     /**
  2616.      * Get value of isNotificationSent flag
  2617.      *
  2618.      * @return boolean
  2619.      */
  2620.     public function isNotificationSent()
  2621.     {
  2622.         return $this->isNotificationSent;
  2623.     }
  2625.     /**
  2626.      * Set value of isNotificationsAllowedFlag flag and return old value
  2627.      *
  2628.      * @param boolean $value New value
  2629.      *
  2630.      * @return boolean
  2631.      */
  2632.     public function setIsNotificationsAllowedFlag($value)
  2633.     {
  2634.         $oldValue = $this->isNotificationsAllowedFlag;
  2635.         $this->isNotificationsAllowedFlag = (bool)$value;
  2637.         return $oldValue;
  2638.     }
  2640.     /**
  2641.      * Set value of ignoreCustomerNotifications flag and return old value
  2642.      *
  2643.      * @param boolean $value New value
  2644.      *
  2645.      * @return boolean
  2646.      */
  2647.     public function setIgnoreCustomerNotifications($value)
  2648.     {
  2649.         $oldValue = $this->ignoreCustomerNotifications;
  2650.         $this->ignoreCustomerNotifications = (bool)$value;
  2652.         return $oldValue;
  2653.     }
  2655.     /**
  2656.      * Get value of isNotificationsAllowedFlag flag
  2657.      *
  2658.      * @return boolean
  2659.      */
  2660.     protected function isNotificationsAllowed()
  2661.     {
  2662.         return $this->isNotificationsAllowedFlag;
  2663.     }
  2665.     /**
  2666.      * Get value of ignoreCustomerNotifications flag
  2667.      *
  2668.      * @return boolean
  2669.      */
  2670.     protected function isIgnoreCustomerNotifications()
  2671.     {
  2672.         return $this->ignoreCustomerNotifications;
  2673.     }
  2675.     // }}}
  2677.     // {{{ Calculation
  2679.     /**
  2680.      * Get modifiers
  2681.      *
  2682.      * @return \XLite\DataSet\Collection\OrderModifier
  2683.      */
  2684.     public function getModifiers()
  2685.     {
  2686.         if ($this->modifiers === null) {
  2687.             $this->modifiers = \XLite\Core\Database::getRepo('XLite\Model\Order\Modifier')->findActive();
  2689.             // Initialize
  2690.             foreach ($this->modifiers as $modifier) {
  2691.                 $modifier->initialize($this, $this->modifiers);
  2692.             }
  2694.             // Preprocess modifiers
  2695.             foreach ($this->modifiers as $modifier) {
  2696.                 $modifier->preprocess();
  2697.             }
  2698.         }
  2700.         return $this->modifiers;
  2701.     }
  2703.     /**
  2704.      * Get modifier
  2705.      *
  2706.      * @param string $type Modifier type
  2707.      * @param string $code Modifier code
  2708.      *
  2709.      * @return \XLite\Model\Order\Modifier
  2710.      */
  2711.     public function getModifier($type, $code)
  2712.     {
  2713.         $result = null;
  2715.         foreach ($this->getModifiers() as $modifier) {
  2716.             if ($modifier->getType() === $type && $modifier->getCode() === $code) {
  2717.                 $result = $modifier;
  2718.                 break;
  2719.             }
  2720.         }
  2722.         return $result;
  2723.     }
  2725.     /**
  2726.      * Check - modifier is exists or not (by type)
  2727.      *
  2728.      * @param string $type Type
  2729.      *
  2730.      * @return boolean
  2731.      */
  2732.     public function isModifierByType($type)
  2733.     {
  2734.         $result = false;
  2736.         foreach ($this->getModifiers() as $modifier) {
  2737.             if ($modifier->getType() === $type) {
  2738.                 $result = true;
  2739.                 break;
  2740.             }
  2741.         }
  2743.         return $result;
  2744.     }
  2746.     /**
  2747.      * Get modifiers by type
  2748.      *
  2749.      * @param string $type Modifier type
  2750.      *
  2751.      * @return array
  2752.      */
  2753.     public function getModifiersByType($type)
  2754.     {
  2755.         $list = [];
  2757.         foreach ($this->getModifiers() as $modifier) {
  2758.             if ($modifier->getType() === $type) {
  2759.                 $list[] = $modifier;
  2760.             }
  2761.         }
  2763.         return $list;
  2764.     }
  2766.     /**
  2767.      * Get items exclude surcharges info
  2768.      *
  2769.      * @return array
  2770.      */
  2771.     public function getItemsExcludeSurcharges()
  2772.     {
  2773.         $list = [];
  2775.         foreach ($this->getItems() as $item) {
  2776.             foreach ($item->getExcludeSurcharges() as $surcharge) {
  2777.                 if (!isset($list[$surcharge->getKey()])) {
  2778.                     $list[$surcharge->getKey()] = $surcharge->getName();
  2779.                 }
  2780.             }
  2781.         }
  2783.         return $list;
  2784.     }
  2786.     /**
  2787.      * Get items included surcharges totals
  2788.      *
  2789.      * @param boolean $forCartItems Flag: true - return values for cart items only, false - for cart totals and items
  2790.      *
  2791.      * @return array
  2792.      */
  2793.     public function getItemsIncludeSurchargesTotals($forCartItems = false)
  2794.     {
  2795.         $list = [];
  2797.         if ($forCartItems) {
  2798.             // Add surcharges for cart items
  2799.             foreach ($this->getItems() as $item) {
  2800.                 foreach ($item->getIncludeSurcharges() as $surcharge) {
  2801.                     if (!isset($list[$surcharge->getKey()])) {
  2802.                         $list[$surcharge->getKey()] = [
  2803.                             'surcharge' => $surcharge,
  2804.                             'cost'      => 0,
  2805.                         ];
  2806.                     }
  2808.                     $list[$surcharge->getKey()]['cost'] += $surcharge->getValue();
  2809.                 }
  2810.             }
  2811.         } else {
  2812.             // Get global cart surcharges
  2813.             foreach ($this->getIncludeSurcharges() as $surcharge) {
  2814.                 if (!isset($list[$surcharge->getKey()])) {
  2815.                     $list[$surcharge->getKey()] = [
  2816.                         'surcharge' => $surcharge,
  2817.                         'cost'      => 0,
  2818.                     ];
  2819.                 }
  2821.                 $list[$surcharge->getKey()]['cost'] += $surcharge->getValue();
  2822.             }
  2823.         }
  2825.         return $list;
  2826.     }
  2828.     /**
  2829.      * Common method to update cart/order
  2830.      *
  2831.      * @return void
  2832.      */
  2833.     public function updateOrder()
  2834.     {
  2835.         $this->normalizeItems();
  2837.         $this->reinitializeCurrency();
  2839.         // If shipping method is not selected or shipping conditions is changed (remove order items or changed address)
  2840.         $this->renewShippingMethod();
  2842.         $this->calculateInitialValues();
  2844.         $this->calculate();
  2846.         $this->renewPaymentMethod();
  2847.     }
  2849.     /**
  2850.      * Calculate order
  2851.      *
  2852.      * @return void
  2853.      */
  2854.     public function calculate()
  2855.     {
  2856.         $oldSurcharges = $this->resetSurcharges();
  2858.         $this->reinitializeCurrency();
  2860.         $this->calculateInitialValues();
  2862.         foreach ($this->getModifiers() as $modifier) {
  2863.             if ($modifier->canApply()) {
  2864.                 $modifier->calculate();
  2865.             }
  2866.         }
  2868.         $this->mergeSurcharges($oldSurcharges);
  2870.         $this->finalizeItemsCalculation();
  2872.         $this->setTotal(max($this->getSurchargesTotal(), 0));
  2873.     }
  2875.     /**
  2876.      * Recalculate edited order
  2877.      *
  2878.      * @return void
  2879.      */
  2880.     public function recalculate()
  2881.     {
  2882.         $this->reinitializeCurrency();
  2884.         $this->finalizeItemsCalculation();
  2886.         $this->setTotal($this->getSurchargesTotal());
  2887.     }
  2889.     /**
  2890.      * Renew order
  2891.      *
  2892.      * @return void
  2893.      */
  2894.     public function renew()
  2895.     {
  2896.         foreach ($this->getItems() as $item) {
  2897.             if (!$item->renew()) {
  2898.                 $this->getItems()->removeElement($item);
  2899.                 \XLite\Core\Database::getRepo('XLite\Model\OrderItem')->delete($item);
  2900.             }
  2901.         }
  2903.         $this->calculate();
  2904.     }
  2906.     /**
  2907.      * Soft renew
  2908.      *
  2909.      * @return void
  2910.      */
  2911.     public function renewSoft()
  2912.     {
  2913.         $this->reinitializeCurrency();
  2914.     }
  2916.     /**
  2917.      * Reinitialize currency
  2918.      *
  2919.      * @return void
  2920.      */
  2921.     protected function reinitializeCurrency()
  2922.     {
  2923.         $new = $this->defineCurrency();
  2924.         $old = $this->getCurrency();
  2926.         if (empty($old) || (!empty($new) && $old->getCode() !== $new->getCode())) {
  2927.             $this->setCurrency($new);
  2928.         }
  2929.     }
  2931.     /**
  2932.      * Define order currency
  2933.      *
  2934.      * @return \XLite\Model\Currency
  2935.      */
  2936.     protected function defineCurrency()
  2937.     {
  2938.         return \XLite::getInstance()->getCurrency();
  2939.     }
  2941.     /**
  2942.      * Reset surcharges list
  2943.      *
  2944.      * @return array
  2945.      */
  2946.     public function resetSurcharges()
  2947.     {
  2948.         $result = [
  2949.             'items' => [],
  2950.         ];
  2952.         $result['items'] = $this->resetItemsSurcharges($this->getItems()->toArray());
  2953.         $result['surcharges'] = parent::resetSurcharges();
  2955.         return $result;
  2956.     }
  2958.     /**
  2959.      * Reset order items surcharge
  2960.      *
  2961.      * @param \XLite\Model\OrderItem[] $items Order items
  2962.      *
  2963.      * @return array
  2964.      */
  2965.     protected function resetSelfSurcharges($items)
  2966.     {
  2967.         $result = [];
  2969.         foreach ($items as $item) {
  2970.             $result[$item->getItemId()] = $item->resetSurcharges();
  2971.         }
  2973.         return $result;
  2974.     }
  2976.     /**
  2977.      * Reset order items surcharge
  2978.      *
  2979.      * @param \XLite\Model\OrderItem[] $items Order items
  2980.      *
  2981.      * @return array
  2982.      */
  2983.     protected function resetItemsSurcharges($items)
  2984.     {
  2985.         $result = [];
  2987.         foreach ($items as $item) {
  2988.             $result[$item->getItemId() ?: spl_object_hash($item)] = $item->resetSurcharges();
  2989.         }
  2991.         return $result;
  2992.     }
  2994.     /**
  2995.      * Merge surcharges
  2996.      *
  2997.      * @param array $oldSurcharges Old surcharges
  2998.      *
  2999.      * @return void
  3000.      */
  3001.     protected function mergeSurcharges(array $oldSurcharges)
  3002.     {
  3003.         foreach ($this->getItems() as $item) {
  3004.             if (!empty($oldSurcharges['items'][$item->getItemId() ?: spl_object_hash($item)])) {
  3005.                 $item->compareSurcharges($oldSurcharges['items'][$item->getItemId() ?: spl_object_hash($item)]);
  3006.             }
  3007.         }
  3009.         $this->compareSurcharges($oldSurcharges['surcharges']);
  3010.     }
  3012.     /**
  3013.      * Calculate initial order values
  3014.      *
  3015.      * @return void
  3016.      */
  3017.     public function calculateInitialValues()
  3018.     {
  3019.         $subtotal = 0;
  3021.         foreach ($this->getItems() as $item) {
  3022.             $item->calculate();
  3024.             $subtotal += $item->getSubtotal();
  3025.         }
  3027.         $subtotal = $this->getCurrency()->roundValue($subtotal);
  3029.         $this->setSubtotal($subtotal);
  3030.         $this->setTotal($subtotal);
  3031.     }
  3034.     /**
  3035.      * Finalize items calculation
  3036.      *
  3037.      * @return void
  3038.      */
  3039.     protected function finalizeItemsCalculation()
  3040.     {
  3041.         $subtotal = 0;
  3042.         foreach ($this->getItems() as $item) {
  3043.             $itemTotal = $item->calculateTotal();
  3044.             $subtotal += $itemTotal;
  3045.             $item->setTotal($itemTotal);
  3046.         }
  3048.         $this->setSubtotal($subtotal);
  3049.         $this->setTotal($subtotal);
  3050.     }
  3052.     // }}}
  3054.     // {{{ Surcharges
  3056.     /**
  3057.      * Get surcharges by type
  3058.      *
  3059.      * @param string $type Surcharge type
  3060.      *
  3061.      * @return list<Surcharge>
  3062.      */
  3063.     public function getSurchargesByType($type = null)
  3064.     {
  3065.         if ($type) {
  3066.             $list = [];
  3067.             foreach ($this->getSurcharges() as $surcharge) {
  3068.                 if ($surcharge->getType() === $type) {
  3069.                     $list[] = $surcharge;
  3070.                 }
  3071.             }
  3072.         } else {
  3073.             $list = $this->getSurcharges();
  3074.         }
  3076.         return $list;
  3077.     }
  3079.     /**
  3080.      * Get surcharges subtotal with specified type
  3081.      *
  3082.      * @param string  $type    Surcharge type OPTIONAL
  3083.      * @param boolean $include Surcharge include flag OPTIONAL
  3084.      *
  3085.      * @return float
  3086.      */
  3087.     public function getSurchargesSubtotal($type = null, $include = null)
  3088.     {
  3089.         $subtotal = 0;
  3090.         $surcharges = $this->getSurchargesByType($type);
  3092.         foreach ($surcharges as $surcharge) {
  3093.             if ($surcharge->getAvailable() && ($include === null || $surcharge->getInclude() === $include)) {
  3094.                 $subtotal += $this->getCurrency()->roundValue($surcharge->getValue());
  3095.             }
  3096.         }
  3098.         return $subtotal;
  3099.     }
  3101.     /**
  3102.      * Get subtotal for displaying
  3103.      *
  3104.      * @return float
  3105.      */
  3106.     public function getDisplaySubtotal()
  3107.     {
  3108.         return $this->getSubtotal();
  3109.     }
  3111.     /**
  3112.      * Get surcharges total with specified type
  3113.      *
  3114.      * @param string $type Surcharge type OPTIONAL
  3115.      *
  3116.      * @return float
  3117.      */
  3118.     public function getSurchargesTotal($type = null)
  3119.     {
  3120.         return $this->getSubtotal() + $this->getSurchargesSubtotal($type, false);
  3121.     }
  3123.     // }}}
  3125.     // {{{ Lifecycle callbacks
  3127.     /**
  3128.      * Prepare order before remove operation
  3129.      *
  3130.      * @return void
  3131.      */
  3132.     public function prepareBeforeRemove()
  3133.     {
  3134.         $profile = $this->getProfile();
  3135.         $origProfile = $this->getOrigProfile();
  3137.         try {
  3138.             if ($profile && (!$origProfile || $profile->getProfileId() !== $origProfile->getProfileId())) {
  3139.                 \XLite\Core\Database::getRepo('XLite\Model\Profile')->delete($profile, false);
  3140.             }
  3141.         } catch (\Doctrine\ORM\EntityNotFoundException $e) {
  3142.         }
  3143.     }
  3145.     /**
  3146.      * Since Doctrine lifecycle callbacks do not allow to modify associations, we've added this method
  3147.      *
  3148.      * @param string $type Type of current operation
  3149.      *
  3150.      * @return void
  3151.      */
  3152.     public function prepareEntityBeforeCommit($type)
  3153.     {
  3154.         if ($type === static::ACTION_DELETE) {
  3155.             $this->setOldPaymentStatus(null);
  3156.             $this->setOldShippingStatus(null);
  3158.             $this->updateItemsSales(-1);
  3160.             $this->prepareBeforeRemove();
  3161.         }
  3162.     }
  3164.     // }}}
  3166.     // {{{ Change status routine
  3168.     /**
  3169.      * Get payment status code
  3170.      *
  3171.      * @return string
  3172.      */
  3173.     public function getPaymentStatusCode()
  3174.     {
  3175.         return $this->getPaymentStatus() && $this->getPaymentStatus()->getCode()
  3176.             ? $this->getPaymentStatus()->getCode()
  3177.             : '';
  3178.     }
  3180.     /**
  3181.      * Get shipping status code
  3182.      *
  3183.      * @return string
  3184.      */
  3185.     public function getShippingStatusCode()
  3186.     {
  3187.         return $this->getShippingStatus() && $this->getShippingStatus()->getCode()
  3188.             ? $this->getShippingStatus()->getCode()
  3189.             : '';
  3190.     }
  3192.     /**
  3193.      * Set payment status
  3194.      *
  3195.      * @param mixed $paymentStatus Payment status
  3196.      *
  3197.      * @return void
  3198.      */
  3199.     public function setPaymentStatus($paymentStatus = null)
  3200.     {
  3201.         $this->processStatus($paymentStatus, 'payment');
  3202.     }
  3204.     /**
  3205.      * Set shipping status
  3206.      *
  3207.      * @param mixed $shippingStatus Shipping status
  3208.      *
  3209.      * @return void
  3210.      */
  3211.     public function setShippingStatus($shippingStatus = null)
  3212.     {
  3213.         $this->processStatus($shippingStatus, 'shipping');
  3214.     }
  3216.     /**
  3217.      * Process order status
  3218.      *
  3219.      * @param mixed  $status Status
  3220.      * @param string $type   Type
  3221.      *
  3222.      * @return void
  3223.      */
  3224.     public function processStatus($status, $type)
  3225.     {
  3226.         static $cache = [];
  3228.         if (is_scalar($status)) {
  3229.             if (!isset($cache[$type][$status])) {
  3230.                 $requestedStatus = $status;
  3232.                 if (
  3233.                     is_int($status)
  3234.                     || (is_string($status)
  3235.                         && preg_match('/^[\d]+$/', $status)
  3236.                     )
  3237.                 ) {
  3238.                     $status = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\\' . ucfirst($type))
  3239.                         ->find($status);
  3240.                 } elseif (is_string($status)) {
  3241.                     $status = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\\' . ucfirst($type))
  3242.                         ->findOneByCode($status);
  3243.                 }
  3245.                 $cache[$type][$requestedStatus] = $status;
  3246.             } else {
  3247.                 $status = $cache[$type][$status];
  3248.             }
  3249.         }
  3251.         $this->statusIsSet = true;
  3253.         $this->{'old' . ucfirst($type) . 'Status'} = $this->{$type . 'Status'};
  3254.         $this->{$type . 'Status'} = $status;
  3255.     }
  3257.     /**
  3258.      * Check order statuses
  3259.      *
  3260.      * @return boolean
  3261.      */
  3262.     public function checkStatuses()
  3263.     {
  3264.         $changed = false;
  3265.         $em = Database::getEM();
  3267.         if ($this->statusIsSet) {
  3268.             $this->statusIsSet = false;
  3269.             $statusHandlers = [];
  3271.             foreach (['payment', 'shipping'] as $type) {
  3272.                 $status = $this->{$type . 'Status'};
  3273.                 $oldStatus = $this->{'old' . ucfirst($type) . 'Status'};
  3274.                 if (
  3275.                     $status
  3276.                     && $oldStatus
  3277.                     && $status->getId() !== $oldStatus->getId()
  3278.                 ) {
  3279.                     $em->addAfterFlushCallback(function () use ($oldStatus, $status, $type) {
  3280.                         \XLite\Core\OrderHistory::getInstance()->registerOrderChangeStatus(
  3281.                             $this->getOrderId(),
  3282.                             [
  3283.                                 'old'  => $oldStatus,
  3284.                                 'new'  => $status,
  3285.                                 'type' => $type,
  3286.                             ]
  3287.                         );
  3289.                         $this->processStatusAnyToAny($oldStatus, $status, $type);
  3290.                     });
  3292.                     $statusHandlers = array_merge(
  3293.                         $this->getStatusHandlers($oldStatus, $status, $type),
  3294.                         $statusHandlers
  3295.                     );
  3297.                     $changed = true;
  3298.                 } elseif (!$oldStatus) {
  3299.                     $this->{'old' . ucfirst($type) . 'Status'} = $this->{$type . 'Status'};
  3300.                 }
  3301.             }
  3303.             $em->addAfterFlushCallback(function () use ($changed, $statusHandlers) {
  3304.                 if ($changed) {
  3305.                     $this->checkInventory();
  3306.                 }
  3308.                 if ($statusHandlers) {
  3309.                     foreach (array_unique($statusHandlers) as $handler) {
  3310.                         $this->{'process' . ucfirst($handler)}();
  3311.                     }
  3312.                 }
  3314.                 foreach (['payment', 'shipping'] as $type) {
  3315.                     $this->{'old' . ucfirst($type) . 'Status'} = null;
  3316.                 }
  3318.                 if ($changed) {
  3319.                     if (
  3320.                         !$this->isNotificationSent
  3321.                         && $this->isNotificationsAllowed()
  3322.                         && $this->getOrderNumber()
  3323.                     ) {
  3324.                         \XLite\Core\Mailer::sendOrderChanged($this, $this->isIgnoreCustomerNotifications());
  3325.                     }
  3326.                 }
  3327.             });
  3328.         }
  3330.         return $changed;
  3331.     }
  3333.     /**
  3334.      * Check inventory
  3335.      *
  3336.      * @throws \Doctrine\ORM\OptimisticLockException
  3337.      */
  3338.     public function checkInventory()
  3339.     {
  3340.         $property = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\Property')->findOneBy(
  3341.             [
  3342.                 'paymentStatus'  => $this->paymentStatus,
  3343.                 'shippingStatus' => $this->shippingStatus,
  3344.             ]
  3345.         );
  3347.         $incStock = $property ? $property->getIncStock() : null;
  3348.         if ($incStock !== null) {
  3349.             $stokStatus = $this->getStockStatus();
  3351.             $oldIncStock = null;
  3352.             if ($stokStatus === 'increased') {
  3353.                 $oldIncStock = true;
  3354.             } elseif ($stokStatus === 'reduced') {
  3355.                 $oldIncStock = false;
  3356.             }
  3358.             if ($oldIncStock === null) {
  3359.                 $property    = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\Property')->findOneBy(
  3360.                     [
  3361.                         'paymentStatus'  => $this->oldPaymentStatus,
  3362.                         'shippingStatus' => $this->oldShippingStatus,
  3363.                     ]
  3364.                 );
  3365.                 $oldIncStock = $property ? $property->getIncStock() : null;
  3366.             }
  3368.             if ($oldIncStock !== null && $incStock !== $oldIncStock) {
  3369.                 if ($incStock) {
  3370.                     $this->processIncrease();
  3371.                     $this->setStockStatus('increased');
  3372.                 } else {
  3373.                     $this->processDecrease();
  3374.                     $this->setStockStatus('reduced');
  3375.                 }
  3376.             }
  3377.         }
  3379.         $this->updateSales();
  3381.         \XLite\Core\Database::getEM()->flush();
  3382.     }
  3384.     /**
  3385.      * Transform attributes: remove relations between order item attributes and product attribute values
  3386.      * to avoid data lost after product attribute values modification
  3387.      *
  3388.      * @return void
  3389.      */
  3390.     public function transformItemsAttributes()
  3391.     {
  3392.         foreach ($this->getItems() as $item) {
  3393.             if ($item->hasAttributeValues()) {
  3394.                 foreach ($item->getAttributeValues() as $av) {
  3395.                     if ($av->getAttributeValue()) {
  3396.                         $attributeValue = $av->getAttributeValue();
  3397.                         $av->setName($attributeValue->getAttribute()->getName());
  3398.                         if (!($attributeValue instanceof \XLite\Model\AttributeValue\AttributeValueText)) {
  3399.                             $av->setValue($attributeValue->asString());
  3400.                         }
  3401.                         $av->setAttributeId($attributeValue->getAttribute()->getId());
  3402.                     }
  3403.                 }
  3404.             }
  3405.         }
  3406.     }
  3408.     /**
  3409.      * These handlers will be used in systemStatus1->...customStatus(es)..->systemStatus2 transition
  3410.      * by default, don't try to cast old statuses
  3411.      * @param string $type Type
  3412.      *
  3413.      * @return array
  3414.      */
  3415.     protected function getStatusHandlersForCast($type)
  3416.     {
  3417.         return [];
  3418.     }
  3420.     /**
  3421.      * Return base part of the certain "change status" handler name
  3422.      *
  3423.      * @param mixed  $oldStatus  Old order status
  3424.      * @param mixed  $newStatus  New order status
  3425.      * @param string $type Type
  3426.      *
  3427.      * @return string|array
  3428.      */
  3429.     protected function getStatusHandlers($oldStatus, $newStatus, $type)
  3430.     {
  3431.         $class = '\XLite\Model\Order\Status\\' . ucfirst($type);
  3433.         $oldCode = $oldStatus->getCode();
  3434.         $newCode = $newStatus->getCode();
  3435.         $statusHandlers = $class::getStatusHandlers();
  3437.         $result = [];
  3439.         if ($oldCode && $newCode && isset($statusHandlers[$oldCode][$newCode])) {
  3440.             $result = is_array($statusHandlers[$oldCode][$newCode])
  3441.                 ? array_unique($statusHandlers[$oldCode][$newCode])
  3442.                 : $statusHandlers[$oldCode][$newCode];
  3443.         }
  3445.         return $result;
  3446.     }
  3448.     /**
  3449.      * @param array $inStatusHandlers
  3450.      *
  3451.      * @return array
  3452.      */
  3453.     protected function getFlatStatuses($inStatusHandlers = [])
  3454.     {
  3455.         $flatStatuses = array_reduce($inStatusHandlers, static function ($a, $b) {
  3456.             return array_merge($a, (array) $b);
  3457.         }, []);
  3459.         return array_unique(array_merge(array_keys($flatStatuses), array_keys($inStatusHandlers)));
  3460.     }
  3462.     /**
  3463.      * A "change status" handler
  3464.      *
  3465.      * @return void
  3466.      */
  3467.     protected function processCheckout()
  3468.     {
  3469.     }
  3471.     /**
  3472.      * A "change status" handler
  3473.      *
  3474.      * @return void
  3475.      */
  3476.     protected function processDecrease()
  3477.     {
  3478.         $this->decreaseInventory();
  3479.     }
  3481.     /**
  3482.      * A "change status" handler
  3483.      *
  3484.      * @return void
  3485.      */
  3486.     protected function processUncheckout()
  3487.     {
  3488.     }
  3490.     /**
  3491.      * A "change status" handler
  3492.      *
  3493.      * @return void
  3494.      */
  3495.     protected function processQueue()
  3496.     {
  3497.     }
  3499.     /**
  3500.      * A "change status" handler
  3501.      *
  3502.      * @return void
  3503.      */
  3504.     protected function processAuthorize()
  3505.     {
  3506.         if ($this instanceof Cart) {
  3507.             $this->setIsNotificationsAllowedFlag(false);
  3508.         }
  3509.     }
  3511.     /**
  3512.      * A "change status" handler
  3513.      *
  3514.      * @return void
  3515.      * @throws \JsonException
  3516.      */
  3517.     protected function processProcess()
  3518.     {
  3519.         /** @var GmvTrackerDomain $gmvTracker */
  3520.         $gmvTracker = \XCart\Container::getContainer()->get(GmvTrackerDomain::class);
  3521.         $gmvOrderData = $gmvTracker->prepareOrderGmvData($this);
  3522.         $gmvTracker->saveOrderGmvData($gmvOrderData);
  3524.         if ($this->isNotificationsAllowed()) {
  3525.             \XLite\Core\Mailer::sendOrderProcessed($this, $this->isIgnoreCustomerNotifications());
  3526.         }
  3528.         $this->setIsNotificationSent(true);
  3529.     }
  3531.     /**
  3532.      * A "change status" handler
  3533.      *
  3534.      * @return void
  3535.      */
  3536.     protected function processShip()
  3537.     {
  3538.         if ($this->isNotificationsAllowed() && !$this->isIgnoreCustomerNotifications()) {
  3539.             \XLite\Core\Mailer::sendOrderShipped($this);
  3540.         }
  3542.         $this->setIsNotificationSent(true);
  3543.     }
  3545.     /**
  3546.      * A "change status" handler
  3547.      *
  3548.      * @return void
  3549.      */
  3550.     protected function processWaitingForApprove()
  3551.     {
  3552.         if ($this->isNotificationsAllowed() && !$this->isIgnoreCustomerNotifications()) {
  3553.             \XLite\Core\Mailer::sendOrderWaitingForApprove($this);
  3554.         }
  3556.         $this->setIsNotificationSent(true);
  3557.     }
  3559.     /**
  3560.      * A "change status" handler
  3561.      *
  3562.      * @return void
  3563.      */
  3564.     protected function processReleaseBackorder()
  3565.     {
  3566.         foreach ($this->getItems() as $item) {
  3567.             $item->releaseBackorder();
  3568.         }
  3569.     }
  3571.     /**
  3572.      * A "change status" handler
  3573.      *
  3574.      * @return void
  3575.      */
  3576.     protected function processIncrease()
  3577.     {
  3578.         $this->increaseInventory();
  3579.     }
  3581.     /**
  3582.      * A "change status" handler
  3583.      *
  3584.      * @return void
  3585.      */
  3586.     protected function processDecline()
  3587.     {
  3588.     }
  3590.     /**
  3591.      * A "change status" handler
  3592.      *
  3593.      * @return void
  3594.      */
  3595.     protected function processFail()
  3596.     {
  3597.         if ($this->isNotificationsAllowed() && $this->getOrderNumber()) {
  3598.             \XLite\Core\Mailer::sendOrderFailed($this, $this->isIgnoreCustomerNotifications());
  3599.         }
  3601.         $this->setIsNotificationSent(true);
  3602.     }
  3604.     /**
  3605.      * A "change status" handler
  3606.      *
  3607.      * @return void
  3608.      */
  3609.     protected function processCancel()
  3610.     {
  3611.         if ($this->isNotificationsAllowed()) {
  3612.             \XLite\Core\Mailer::sendOrderCanceled($this, $this->isIgnoreCustomerNotifications());
  3613.         }
  3615.         $this->setIsNotificationSent(true);
  3616.     }
  3618.     /**
  3619.      * Status change handler for the "any to any" event.
  3620.      * 1)Allows to run handlers on systemStatus1->...customStatus(es)..->systemStatus2 transition
  3621.      *   Attention! handlers must include internal checking to avoid double execution
  3622.      *
  3623.      * @param $oldStatus
  3624.      * @param $newStatus
  3625.      * @param $type
  3626.      */
  3627.     protected function processStatusAnyToAny($oldStatus, $newStatus, $type)
  3628.     {
  3629.         // here is the key point to decide if we try to find an old system status in order history
  3630.         $statusHandlers2Cast = $this->getStatusHandlersForCast($type);
  3632.         if (!$statusHandlers2Cast) {
  3633.             return;
  3634.         }
  3635.         // Transitions between these statuses are valued only
  3636.         $businessLogicStatuses = $this->getFlatStatuses($statusHandlers2Cast);
  3638.         $inOldCode = $oldStatus->getCode();
  3639.         $inNewCode = $newStatus->getCode();
  3641.         // cycle is used for performance only, 'continue' below avoids unnecessary code execution
  3642.         foreach ($statusHandlers2Cast as $oldCode2Deal => $newCodes2Deal) {
  3643.             if (
  3644.                 $oldCode2Deal === $inOldCode // exact handler will be returned/launched by getStatusHandlers, do nothing
  3645.                 || !in_array($inNewCode, array_keys($newCodes2Deal)) // nothing to deal with here
  3646.                 || in_array($inOldCode, $businessLogicStatuses) // take into account transition from custom statuses to business statuses only
  3647.             ) {
  3648.                 continue;
  3649.             }
  3651.             // find the nearest business(system) status code from order history
  3652.             $oldSystemBusinessCode = $this->getNearestOldBusinessCode($inOldCode, $businessLogicStatuses, $type);
  3654.             if (
  3655.                 $oldSystemBusinessCode !== $inOldCode
  3656.                 && isset($statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode])
  3657.             ) {
  3658.                 // We have found an old business code before a bunch of meaningless ones
  3659.                 $castHandlers = is_array($statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode])
  3660.                     ? array_unique($statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode])
  3661.                     : [$statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode]];
  3663.                 foreach ($castHandlers as $castHandler) {
  3664.                     // here we run a handler for a cast oldBusinessStatus->...someStatuses...->newBusinessStatus transition
  3665.                     $methodOnStatusChange = 'process' . \Includes\Utils\Converter::convertToUpperCamelCase($castHandler);
  3666.                     if (method_exists($this, $methodOnStatusChange)) {
  3667.                         $this->$methodOnStatusChange();
  3668.                     }
  3669.                 }
  3670.                 // typecast old code only once
  3671.                 break;
  3672.             }
  3673.         }
  3674.     }
  3676.     /**
  3677.      * Find backwards the nearest old business(system) code before a bunch of non-business logic codes
  3678.      *
  3679.      * @param $meaninglessOldCode
  3680.      * @param $businessLogicStatuses
  3681.      * @param $type
  3682.      *
  3683.      * @return string
  3684.      */
  3685.     protected function getNearestOldBusinessCode($meaninglessOldCode, $businessLogicStatuses, $type)
  3686.     {
  3687.         // this shared static cache is supposed to be used in other functions in the future. use the key ['OrderHistoryEvents', $this->getOrderId()]
  3688.         $historyList = $this->executeCachedRuntime(function () {
  3689.             return \XLite\Core\Database::getRepo('XLite\Model\OrderHistoryEvents')->findAllByOrder($this) ?: [];
  3690.         }, ['OrderHistoryEvents', $this->getOrderId()]) ?: [];
  3692.         $eventCodeName = $type === 'payment' ? \XLite\Core\OrderHistory::CODE_CHANGE_PAYMENT_STATUS_ORDER : \XLite\Core\OrderHistory::CODE_CHANGE_SHIPPING_STATUS_ORDER;
  3693.         $historyList = array_filter($historyList, static function ($event) use ($eventCodeName) {
  3694.             return $event->getCode() === $eventCodeName;
  3695.         });
  3697.         foreach ($historyList as $event) {
  3698.             $oldOrderStatus = $event->getData()['oldStatusCode'];
  3699.             if (in_array($oldOrderStatus, $businessLogicStatuses)) {
  3700.                 return $oldOrderStatus;
  3701.             }
  3702.         }
  3704.         return $meaninglessOldCode;
  3705.     }
  3706.     // }}}
  3708.     // {{{ Inventory tracking
  3710.     /**
  3711.      * Increase / decrease item products inventory
  3712.      *
  3713.      * @param integer $sign Flag; "1" or "-1"
  3714.      *
  3715.      * @return void
  3716.      */
  3717.     protected function changeItemsInventory($sign)
  3718.     {
  3719.         $registerAsGroup = 1 < count($this->getItems());
  3720.         $data = [];
  3721.         foreach ($this->getItems() as $item) {
  3722.             $delta = $sign * $item->getAmount();
  3724.             if ($delta !== 0) {
  3725.                 $data[] = $this->getGroupedDataItem($item, $delta);
  3726.             }
  3727.         }
  3729.         if ($registerAsGroup) {
  3730.             \XLite\Core\OrderHistory::getInstance()->registerChangeAmountGrouped(
  3731.                 $this->getOrderId(),
  3732.                 $data
  3733.             );
  3734.         }
  3736.         foreach ($this->getItems() as $item) {
  3737.             $this->changeItemInventory($item, $sign, !$registerAsGroup);
  3738.         }
  3739.     }
  3741.     /**
  3742.      * Get grouped data item
  3743.      *
  3744.      * @param \XLite\Model\OrderItem    $item       Order item
  3745.      * @param integer                   $amount     Amount
  3746.      *
  3747.      * @return array
  3748.      */
  3749.     protected function getGroupedDataItem($item, $amount)
  3750.     {
  3751.         return [
  3752.             'item'      => $item,
  3753.             'amount'    => $item->getProduct()->getPublicAmount(),
  3754.             'delta'     => $amount,
  3755.         ];
  3756.     }
  3758.     /**
  3759.      * Increase / decrease item product inventory
  3760.      *
  3761.      * @param \XLite\Model\OrderItem $item      Order item
  3762.      * @param integer                $sign      Flag; "1" or "-1"
  3763.      * @param boolean                $register  Register in order history OPTIONAL
  3764.      *
  3765.      * @return integer
  3766.      */
  3767.     protected function changeItemInventory($item, $sign, $register = true)
  3768.     {
  3769.         $delta = $sign * $item->getAmount();
  3771.         $realDelta = $delta > 0 && $item->getBackorderedAmount() > 0
  3772.             ? $delta - $item->getBackorderedAmount()
  3773.             : $delta;
  3775.         if ($realDelta !== 0) {
  3776.             if ($register) {
  3777.                 $this->registerHistoryChangeItemAmount($item, $realDelta);
  3778.             }
  3779.             $item->changeAmount($realDelta);
  3780.         }
  3782.         return $realDelta;
  3783.     }
  3785.     /**
  3786.      * @param \XLite\Model\OrderItem $item
  3787.      * @param integer                $delta
  3788.      */
  3789.     protected function registerHistoryChangeItemAmount($item, $delta)
  3790.     {
  3791.         $history = \XLite\Core\OrderHistory::getInstance();
  3792.         $history->registerChangeAmount($this->getOrderId(), $item->getProduct(), $delta);
  3793.     }
  3795.     /**
  3796.      * Order processed: decrease products inventory
  3797.      *
  3798.      * @return void
  3799.      */
  3800.     protected function decreaseInventory()
  3801.     {
  3802.         $this->changeItemsInventory(-1);
  3803.     }
  3805.     /**
  3806.      * Order declined: increase products inventory
  3807.      *
  3808.      * @return void
  3809.      */
  3810.     protected function increaseInventory()
  3811.     {
  3812.         $this->changeItemsInventory(1);
  3813.     }
  3815.     // }}}
  3817.     // {{{ Order actions
  3819.     /**
  3820.      * Get allowed actions
  3821.      *
  3822.      * @return array
  3823.      */
  3824.     public function getAllowedActions()
  3825.     {
  3826.         return [];
  3827.     }
  3829.     /**
  3830.      * Get allowed payment actions
  3831.      *
  3832.      * @return array
  3833.      */
  3834.     public function getAllowedPaymentActions()
  3835.     {
  3836.         $actions = [];
  3838.         $transactions = $this->getPaymentTransactions();
  3840.         if ($transactions) {
  3841.             foreach ($transactions as $transaction) {
  3842.                 $processor = $transaction->getPaymentMethod()
  3843.                     ? $transaction->getPaymentMethod()->getProcessor()
  3844.                     : null;
  3846.                 if ($processor) {
  3847.                     $allowedTransactions = $processor->getAllowedTransactions();
  3849.                     foreach ($allowedTransactions as $transactionType) {
  3850.                         if ($processor->isTransactionAllowed($transaction, $transactionType)) {
  3851.                             $actions[$transactionType] = $transaction->getTransactionId();
  3852.                         }
  3853.                     }
  3854.                 }
  3855.             }
  3856.         }
  3858.         return $actions;
  3859.     }
  3861.     /**
  3862.      * Get array of payment transaction sums (how much is authorized, captured and refunded)
  3863.      *
  3864.      * @return array
  3865.      */
  3866.     public function getPaymentTransactionSums()
  3867.     {
  3868.         $paymentTransactionSums = $this->getRawPaymentTransactionSums();
  3870.         $lblAuth = (string) static::t('Authorized amount');
  3871.         $lblCapture = (string) static::t('Captured amount');
  3872.         $lblRefunded = (string) static::t('Refunded amount');
  3874.         $paymentTransactionSums = [
  3875.             $lblAuth     => $paymentTransactionSums['authorized'],
  3876.             $lblCapture  => $paymentTransactionSums['captured'],
  3877.             $lblRefunded => $paymentTransactionSums['refunded'],
  3878.         ];
  3880.         // Remove from array all zero sums
  3881.         foreach ($paymentTransactionSums as $k => $v) {
  3882.             if (0.01 >= $v) {
  3883.                 unset($paymentTransactionSums[$k]);
  3884.             }
  3885.         }
  3887.         return $paymentTransactionSums;
  3888.     }
  3890.     /**
  3891.      * Get array of raw payment transaction sums
  3892.      *
  3893.      * @param boolean $override Override cache OPTIONAL
  3894.      *
  3895.      * @return array
  3896.      */
  3897.     public function getRawPaymentTransactionSums($override = false)
  3898.     {
  3899.         if ($this->paymentTransactionSums === null || $override) {
  3900.             $transactions = $this->getPaymentTransactions();
  3902.             $this->paymentTransactionSums = [
  3903.                 'authorized' => 0,
  3904.                 'captured'   => 0,
  3905.                 'refunded'   => 0,
  3906.                 'sale'       => 0,
  3907.                 'blocked'    => 0,
  3908.             ];
  3910.             foreach ($transactions as $t) {
  3911.                 if ($t->isPersistent()) {
  3912.                     \XLite\Core\Database::getEM()->refresh($t);
  3913.                 }
  3914.                 $backendTransactions = $t->getBackendTransactions();
  3916.                 $authorized = 0;
  3918.                 if ($backendTransactions && count($backendTransactions) > 0) {
  3919.                     // By backend transactions
  3920.                     foreach ($backendTransactions as $bt) {
  3921.                         if ($bt->isCompleted()) {
  3922.                             switch ($bt->getType()) {
  3923.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_AUTH:
  3924.                                     $authorized += $bt->getValue();
  3925.                                     $this->paymentTransactionSums['blocked'] += $bt->getValue();
  3926.                                     break;
  3928.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_SALE:
  3929.                                     $this->paymentTransactionSums['blocked'] += $bt->getValue();
  3930.                                     $this->paymentTransactionSums['sale'] += $bt->getValue();
  3931.                                     break;
  3933.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE:
  3934.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE_PART:
  3935.                                     $this->paymentTransactionSums['captured'] += $bt->getValue();
  3936.                                     $authorized -= $bt->getValue();
  3937.                                     $this->paymentTransactionSums['sale'] += $bt->getValue();
  3938.                                     break;
  3940.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND:
  3941.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_PART:
  3942.                                     $this->paymentTransactionSums['refunded'] += $bt->getValue();
  3943.                                     $this->paymentTransactionSums['blocked'] -= $bt->getValue();
  3944.                                     $this->paymentTransactionSums['sale'] -= $bt->getValue();
  3945.                                     break;
  3947.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_MULTI:
  3948.                                     $this->paymentTransactionSums['refunded'] += $bt->getValue();
  3949.                                     $authorized -= $bt->getValue();
  3950.                                     $this->paymentTransactionSums['blocked'] -= $bt->getValue();
  3951.                                     $this->paymentTransactionSums['sale'] -= $bt->getValue();
  3952.                                     break;
  3954.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID:
  3955.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID_PART:
  3956.                                     $authorized -= $bt->getValue();
  3957.                                     $this->paymentTransactionSums['blocked'] -= $bt->getValue();
  3958.                                     break;
  3960.                                 default:
  3961.                             }
  3962.                         }
  3963.                     }
  3964.                 } else {
  3965.                     // By transaction
  3966.                     if ($t->isCompleted()) {
  3967.                         switch ($t->getType()) {
  3968.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_AUTH:
  3969.                                 $authorized += $t->getValue();
  3970.                                 $this->paymentTransactionSums['blocked'] += $t->getValue();
  3971.                                 break;
  3973.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_SALE:
  3974.                                 $this->paymentTransactionSums['blocked'] += $t->getValue();
  3975.                                 $this->paymentTransactionSums['sale'] += $t->getValue();
  3976.                                 break;
  3978.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE:
  3979.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE_PART:
  3980.                                 $this->paymentTransactionSums['captured'] += $t->getValue();
  3981.                                 $authorized -= $t->getValue();
  3982.                                 $this->paymentTransactionSums['sale'] += $t->getValue();
  3983.                                 break;
  3985.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND:
  3986.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_PART:
  3987.                                 $this->paymentTransactionSums['refunded'] += $t->getValue();
  3988.                                 $this->paymentTransactionSums['blocked'] -= $t->getValue();
  3989.                                 $this->paymentTransactionSums['sale'] -= $t->getValue();
  3990.                                 break;
  3992.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_MULTI:
  3993.                                 $this->paymentTransactionSums['refunded'] += $t->getValue();
  3994.                                 $authorized -= $t->getValue();
  3995.                                 $this->paymentTransactionSums['blocked'] -= $t->getValue();
  3996.                                 $this->paymentTransactionSums['sale'] -= $t->getValue();
  3997.                                 break;
  3999.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID:
  4000.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID_PART:
  4001.                                 $authorized -= $t->getValue();
  4002.                                 $this->paymentTransactionSums['blocked'] -= $t->getValue();
  4003.                                 break;
  4005.                             default:
  4006.                         }
  4007.                     }
  4008.                 }
  4010.                 if (
  4011.                     0 < $authorized
  4012.                     && 0 < $this->paymentTransactionSums['captured']
  4013.                     && !$t->getPaymentMethod()->getProcessor()->isTransactionAllowed($t, \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE_MULTI)
  4014.                 ) {
  4015.                     // Do not take in consideration an authorized sum after capture
  4016.                     // if payment processor does not support multiple partial capture transactions
  4017.                     $authorized = 0;
  4018.                 }
  4020.                 $this->paymentTransactionSums['authorized'] += $authorized;
  4021.             } // foreach
  4023.             $this->paymentTransactionSums = array_map(function ($item) {
  4024.                 return $this->getCurrency()->roundValue($item);
  4025.             }, $this->paymentTransactionSums);
  4026.         }
  4028.         return $this->paymentTransactionSums;
  4029.     }
  4031.     // }}}
  4033.     // {{{ Common for several pages method to use in invoice templates
  4035.     /**
  4036.      * Return true if shipping section should be visible on the invoice
  4037.      *
  4038.      * @return boolean
  4039.      */
  4040.     public function isShippingSectionVisible()
  4041.     {
  4042.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  4044.         return $modifier && $modifier->canApply();
  4045.     }
  4047.     /**
  4048.      * Return true if payment section should be visible on the invoice
  4049.      * (this section is always visible by the default)
  4050.      *
  4051.      * @return boolean
  4052.      */
  4053.     public function isPaymentSectionVisible()
  4054.     {
  4055.         return true;
  4056.     }
  4058.     /**
  4059.      * Return true if payment and/or shipping sections should be visible on the invoice
  4060.      *
  4061.      * @return boolean
  4062.      */
  4063.     public function isPaymentShippingSectionVisible()
  4064.     {
  4065.         return $this->isShippingSectionVisible() || $this->isPaymentSectionVisible();
  4066.     }
  4068.     // }}}
  4070.     /**
  4071.      * Renew payment status.
  4072.      * Return true if payment status has been changed
  4073.      *
  4074.      * @return boolean
  4075.      */
  4076.     public function renewPaymentStatus()
  4077.     {
  4078.         $result = false;
  4080.         $status = $this->getCalculatedPaymentStatus(true);
  4081.         if ($this->getPaymentStatusCode() !== $status) {
  4082.             $this->setPaymentStatus($status);
  4083.             $result = true;
  4084.         }
  4086.         return $result;
  4087.     }
  4089.     /**
  4090.      * Get calculated payment status
  4091.      *
  4092.      * @param boolean $override Override calculation cache OPTIONAL
  4093.      *
  4094.      * @return string
  4095.      */
  4096.     public function getCalculatedPaymentStatus($override = false)
  4097.     {
  4098.         $result = \XLite\Model\Order\Status\Payment::STATUS_QUEUED;
  4100.         $sums = $this->getRawPaymentTransactionSums($override);
  4101.         $total = $this->getCurrency()->roundValue($this->getTotal());
  4103.         if ($total == 0.0) {
  4104.             $result = \XLite\Model\Order\Status\Payment::STATUS_PAID;
  4105.         } elseif ($sums['authorized'] > 0 && $sums['sale'] == 0 && $sums['captured'] == 0) {
  4106.             $result = \XLite\Model\Order\Status\Payment::STATUS_AUTHORIZED;
  4107.         } elseif ($sums['sale'] < $total) {
  4108.             if ($sums['sale'] > 0) {
  4109.                 $result = \XLite\Model\Order\Status\Payment::STATUS_PART_PAID;
  4110.             } elseif ($sums['refunded'] > 0) {
  4111.                 $result = \XLite\Model\Order\Status\Payment::STATUS_REFUNDED;
  4112.             }
  4113.         } else {
  4114.             if ($sums['sale'] > 0 || $sums['captured'] > 0) {
  4115.                 $result = \XLite\Model\Order\Status\Payment::STATUS_PAID;
  4116.             } elseif ($sums['refunded'] > 0) {
  4117.                 $result = \XLite\Model\Order\Status\Payment::STATUS_REFUNDED;
  4118.             }
  4119.         }
  4121.         $lastTransaction = $this->getPaymentTransactions()->last();
  4122.         if ($lastTransaction && $lastTransaction->isVoid()) {
  4123.             $result = \XLite\Model\Order\Status\Payment::STATUS_CANCELED;
  4124.         }
  4126.         if ($result === \XLite\Model\Order\Status\Payment::STATUS_QUEUED) {
  4127.             if ($lastTransaction) {
  4128.                 if ($lastTransaction->isFailed() || $lastTransaction->isVoid()) {
  4129.                     $result = \XLite\Model\Order\Status\Payment::STATUS_DECLINED;
  4130.                 }
  4132.                 if ($lastTransaction->isCanceled()) {
  4133.                     $result = \XLite\Model\Order\Status\Payment::STATUS_CANCELED;
  4134.                 }
  4135.             }
  4136.         }
  4138.         return $result;
  4139.     }
  4141.     /**
  4142.      * Set order status by transaction
  4143.      *
  4144.      * @param \XLite\Model\Payment\Transaction $transaction Transaction which changes status
  4145.      *
  4146.      * @return void
  4147.      */
  4148.     public function setPaymentStatusByTransaction(\XLite\Model\Payment\Transaction $transaction)
  4149.     {
  4150.         if ($this->isPayed()) {
  4151.             $status = $transaction->isCaptured()
  4152.                 ? \XLite\Model\Order\Status\Payment::STATUS_PAID
  4153.                 : \XLite\Model\Order\Status\Payment::STATUS_AUTHORIZED;
  4154.         } else {
  4155.             if ($transaction->isRefunded()) {
  4156.                 $paymentTransactionSums = $this->getRawPaymentTransactionSums(true);
  4157.                 $refunded = $paymentTransactionSums['refunded'];
  4159.                 // Check if the whole refunded sum (along with the previous refunded transactions for the order)
  4160.                 // covers the whole total for order
  4161.                 $status = $this->getCurrency()->roundValue($refunded) < $this->getCurrency()->roundValue($this->getTotal())
  4162.                     ? \XLite\Model\Order\Status\Payment::STATUS_PART_PAID
  4163.                     : \XLite\Model\Order\Status\Payment::STATUS_REFUNDED;
  4164.             } elseif ($transaction->isFailed()) {
  4165.                 $status = \XLite\Model\Order\Status\Payment::STATUS_DECLINED;
  4166.             } elseif ($transaction->isVoid()) {
  4167.                 $status = \XLite\Model\Order\Status\Payment::STATUS_CANCELED;
  4168.             } elseif ($transaction->isCaptured()) {
  4169.                 $status = \XLite\Model\Order\Status\Payment::STATUS_PART_PAID;
  4170.             } else {
  4171.                 $status = \XLite\Model\Order\Status\Payment::STATUS_QUEUED;
  4172.             }
  4173.         }
  4175.         $this->setPaymentStatus($status);
  4176.     }
  4178.     /**
  4179.      * Checks whether order is shippable or not
  4180.      *
  4181.      * @return boolean
  4182.      */
  4183.     public function isShippable()
  4184.     {
  4185.         $result = false;
  4187.         foreach ($this->getItems() as $item) {
  4188.             if ($item->isShippable()) {
  4189.                 $result = true;
  4190.                 break;
  4191.             }
  4192.         }
  4194.         return $result;
  4195.     }
  4197.     /**
  4198.      * Get addresses list
  4199.      *
  4200.      * @return array
  4201.      */
  4202.     public function getAddresses()
  4203.     {
  4204.         $list = $this->getProfile()->getAddresses()->toArray();
  4205.         if ($this->getOrigProfile()) {
  4206.             foreach ($this->getOrigProfile()->getAddresses() as $address) {
  4207.                 $equal = false;
  4208.                 foreach ($list as $address2) {
  4209.                     if (!$equal && $address->isEqualAddress($address2)) {
  4210.                         $equal = true;
  4211.                         break;
  4212.                     }
  4213.                 }
  4215.                 if (!$equal) {
  4216.                     $list[] = $address;
  4217.                 }
  4218.             }
  4219.         }
  4221.         return $list;
  4222.     }
  4224.     /**
  4225.      * Check if all order items in order is valid
  4226.      *
  4227.      * @return boolean
  4228.      */
  4229.     protected function isAllItemsValid()
  4230.     {
  4231.         $result = true;
  4233.         foreach ($this->getItems() as $item) {
  4234.             if (!$item->isValid()) {
  4235.                 $result = false;
  4236.                 break;
  4237.             }
  4238.         }
  4240.         return $result;
  4241.     }
  4243.     /**
  4244.      * Check if all order items in order is configured
  4245.      *
  4246.      * @return boolean
  4247.      */
  4248.     protected function isConfigured()
  4249.     {
  4250.         $isConfigured = true;
  4252.         foreach ($this->getItems() as $item) {
  4253.             if (!$item->isConfigured()) {
  4254.                 $isConfigured = false;
  4255.                 break;
  4256.             }
  4257.         }
  4259.         return $isConfigured;
  4260.     }
  4262.     /**
  4263.      * Get payment transaction data.
  4264.      * These data are displayed on the order page, invoice and packing slip
  4265.      *
  4266.      * @param boolean $isPrimary Flag: true - return only data fields marked by processor as 'primary', false - all fields OPTIONAL
  4267.      *
  4268.      * @return array
  4269.      */
  4270.     public function getPaymentTransactionData($isPrimary = false)
  4271.     {
  4272.         $result = [];
  4274.         $transaction = $this->getPaymentTransactions()
  4275.             ? $this->getPaymentTransactions()->last()
  4276.             : null;
  4278.         if ($transaction) {
  4279.             $method = $transaction->getPaymentMethod() ?: $this->getPaymentMethod();
  4280.             $processor = $method ? $method->getProcessor() : null;
  4282.             if ($processor) {
  4283.                 $result = $processor->getTransactionData($transaction, $isPrimary);
  4284.             }
  4285.         }
  4287.         return $result;
  4288.     }
  4290.     /**
  4291.      * Get last payment transaction ID.
  4292.      * This data is displayed on the order page, invoice and packing slip
  4293.      *
  4294.      * @return string|null
  4295.      */
  4296.     public function getPaymentTransactionId()
  4297.     {
  4298.         $transaction = $this->getPaymentTransactions()
  4299.             ? $this->getPaymentTransactions()->last()
  4300.             : null;
  4302.         return $transaction
  4303.             ? $transaction->getPublicId()
  4304.             : null;
  4305.     }
  4307.     /**
  4308.      * @return bool
  4309.      */
  4310.     public function isOfflineProcessorUsed()
  4311.     {
  4312.         $processor = $this->getPaymentProcessor();
  4314.         return $processor instanceof \XLite\Model\Payment\Processor\Offline;
  4315.     }
  4317.     /**
  4318.      * @return \XLite\Model\Payment\Base\Processor
  4319.      */
  4320.     public function getPaymentProcessor()
  4321.     {
  4322.         $processor = null;
  4324.         $transaction = $this->getPaymentTransactions()
  4325.             ? $this->getPaymentTransactions()->last()
  4326.             : null;
  4328.         if ($transaction) {
  4329.             $method = $transaction->getPaymentMethod() ?: $this->getPaymentMethod();
  4330.             $processor = $method ? $method->getProcessor() : null;
  4331.         }
  4333.         return $processor;
  4334.     }
  4336.     // {{{ Sales statistic
  4338.     /**
  4339.      * Returns old payment status code
  4340.      *
  4341.      * @return string
  4342.      */
  4343.     protected function getOldPaymentStatusCode()
  4344.     {
  4345.         $oldPaymentStatus = $this->oldPaymentStatus;
  4347.         return $oldPaymentStatus && $oldPaymentStatus->getCode()
  4348.             ? $oldPaymentStatus->getCode()
  4349.             : '';
  4350.     }
  4352.     /**
  4353.      * Calculate sales delta
  4354.      *
  4355.      * @return integer|null
  4356.      */
  4357.     protected function getSalesDelta()
  4358.     {
  4359.         $result = null;
  4361.         $newStatusCode = $this->getPaymentStatusCode();
  4362.         if ($newStatusCode) {
  4363.             $oldStatusCode = $this->getOldPaymentStatusCode();
  4364.             $paidStatuses = \XLite\Model\Order\Status\Payment::getPaidStatuses();
  4366.             if (
  4367.                 (!$oldStatusCode || !in_array($oldStatusCode, $paidStatuses, true))
  4368.                 && in_array($newStatusCode, $paidStatuses, true)
  4369.             ) {
  4370.                 $result = 1;
  4371.             } elseif (
  4372.                 $oldStatusCode
  4373.                 && in_array($oldStatusCode, $paidStatuses, true)
  4374.                 && !in_array($newStatusCode, $paidStatuses, true)
  4375.             ) {
  4376.                 $result = -1;
  4377.             }
  4378.         }
  4380.         return $result;
  4381.     }
  4383.     /**
  4384.      * Update sales statistics
  4385.      *
  4386.      * @param integer $delta Delta
  4387.      */
  4388.     protected function updateItemsSales($delta)
  4389.     {
  4390.         if ($delta === null) {
  4391.             return;
  4392.         }
  4394.         foreach ($this->getItems() as $item) {
  4395.             $product = $item->getObject();
  4396.             if ($product === null) {
  4397.                 continue;
  4398.             }
  4400.             $product->setSales(
  4401.                 $product->getSales() + $delta * $item->getAmount()
  4402.             );
  4403.         }
  4404.     }
  4406.     /**
  4407.      * Update sales
  4408.      */
  4409.     protected function updateSales()
  4410.     {
  4411.         $this->updateItemsSales($this->getSalesDelta());
  4412.     }
  4414.     // }}}
  4416.     /**
  4417.      * Get order_id
  4418.      *
  4419.      * @return integer
  4420.      */
  4421.     public function getOrderId()
  4422.     {
  4423.         return $this->order_id;
  4424.     }
  4426.     public function getPublicId(): ?string
  4427.     {
  4428.         return $this->public_id;
  4429.     }
  4431.     /**
  4432.      * Cannot be strict `string` type as there are 'public_id=null' orders after upgrade. #XCB-2685
  4433.      */
  4434.     public function setPublicId(?string $public_id): void
  4435.     {
  4436.         $this->public_id = $public_id;
  4437.     }
  4439.     /**
  4440.      * Set shipping_id
  4441.      *
  4442.      * @param integer $shippingId
  4443.      * @return Order
  4444.      */
  4445.     public function setShippingId($shippingId)
  4446.     {
  4447.         $this->shipping_id = $shippingId;
  4448.         return $this;
  4449.     }
  4451.     /**
  4452.      * Get shipping_id
  4453.      *
  4454.      * @return integer
  4455.      */
  4456.     public function getShippingId()
  4457.     {
  4458.         return $this->shipping_id;
  4459.     }
  4461.     /**
  4462.      * Set shipping_method_name
  4463.      *
  4464.      * @param string $shippingMethodName
  4465.      * @return Order
  4466.      */
  4467.     public function setShippingMethodName($shippingMethodName)
  4468.     {
  4469.         $this->shipping_method_name = $shippingMethodName;
  4470.         return $this;
  4471.     }
  4473.     /**
  4474.      * Set payment_method_name
  4475.      *
  4476.      * @param string $paymentMethodName
  4477.      * @return Order
  4478.      */
  4479.     public function setPaymentMethodName($paymentMethodName)
  4480.     {
  4481.         $this->payment_method_name = $paymentMethodName;
  4482.         return $this;
  4483.     }
  4485.     /**
  4486.      * Set tracking
  4487.      *
  4488.      * @param string $tracking
  4489.      * @return Order
  4490.      */
  4491.     public function setTracking($tracking)
  4492.     {
  4493.         $this->tracking = $tracking;
  4494.         return $this;
  4495.     }
  4497.     /**
  4498.      * Get tracking
  4499.      *
  4500.      * @return string
  4501.      */
  4502.     public function getTracking()
  4503.     {
  4504.         return $this->tracking;
  4505.     }
  4507.     /**
  4508.      * Set date
  4509.      *
  4510.      * @param integer $date
  4511.      * @return Order
  4512.      */
  4513.     public function setDate($date)
  4514.     {
  4515.         $this->date = $date;
  4516.         return $this;
  4517.     }
  4519.     /**
  4520.      * Get date
  4521.      *
  4522.      * @return integer
  4523.      */
  4524.     public function getDate()
  4525.     {
  4526.         return $this->date;
  4527.     }
  4529.     /**
  4530.      * Set lastRenewDate
  4531.      *
  4532.      * @param integer $lastRenewDate
  4533.      * @return Order
  4534.      */
  4535.     public function setLastRenewDate($lastRenewDate)
  4536.     {
  4537.         $this->lastRenewDate = $lastRenewDate;
  4538.         return $this;
  4539.     }
  4541.     /**
  4542.      * Get lastRenewDate
  4543.      *
  4544.      * @return integer
  4545.      */
  4546.     public function getLastRenewDate()
  4547.     {
  4548.         return $this->lastRenewDate;
  4549.     }
  4551.     /**
  4552.      * Set notes
  4553.      *
  4554.      * @param string $notes
  4555.      *
  4556.      * @return Order
  4557.      */
  4558.     public function setNotes($notes)
  4559.     {
  4560.         $this->notes = $notes;
  4561.         return $this;
  4562.     }
  4564.     /**
  4565.      * Get notes
  4566.      *
  4567.      * @return string
  4568.      */
  4569.     public function getNotes()
  4570.     {
  4571.         return $this->notes;
  4572.     }
  4574.     /**
  4575.      * Set adminNotes
  4576.      *
  4577.      * @param string $adminNotes
  4578.      *
  4579.      * @return Order
  4580.      */
  4581.     public function setAdminNotes($adminNotes)
  4582.     {
  4583.         $this->adminNotes = $adminNotes;
  4584.         return $this;
  4585.     }
  4587.     /**
  4588.      * Get adminNotes
  4589.      *
  4590.      * @return string
  4591.      */
  4592.     public function getAdminNotes()
  4593.     {
  4594.         return $this->adminNotes;
  4595.     }
  4597.     public function getSalesChannel(): ?string
  4598.     {
  4599.         return $this->salesChannel;
  4600.     }
  4602.     public function setSalesChannel(?string $salesChannel): Order
  4603.     {
  4604.         $this->salesChannel = $salesChannel;
  4606.         return $this;
  4607.     }
  4609.     /**
  4610.      * Set orderNumber
  4611.      *
  4612.      * @param string $orderNumber
  4613.      * @return Order
  4614.      */
  4615.     public function setOrderNumber($orderNumber)
  4616.     {
  4617.         $this->orderNumber = $orderNumber;
  4618.         return $this;
  4619.     }
  4621.     /**
  4622.      * Get orderNumber
  4623.      *
  4624.      * @return string
  4625.      */
  4626.     public function getOrderNumber()
  4627.     {
  4628.         return $this->orderNumber;
  4629.     }
  4631.     /**
  4632.      * Set recent
  4633.      *
  4634.      * @param boolean $recent
  4635.      * @return Order
  4636.      */
  4637.     public function setRecent($recent)
  4638.     {
  4639.         $this->recent = $recent;
  4640.         return $this;
  4641.     }
  4643.     /**
  4644.      * Get recent
  4645.      *
  4646.      * @return boolean
  4647.      */
  4648.     public function getRecent()
  4649.     {
  4650.         return $this->recent;
  4651.     }
  4653.     /**
  4654.      * Set xcPendingExport
  4655.      *
  4656.      * @param boolean $xcPendingExport
  4657.      * @return Order
  4658.      */
  4659.     public function setXcPendingExport($xcPendingExport)
  4660.     {
  4661.         $this->xcPendingExport = $xcPendingExport;
  4662.         return $this;
  4663.     }
  4665.     /**
  4666.      * Get xcPendingExport
  4667.      *
  4668.      * @return boolean
  4669.      */
  4670.     public function getXcPendingExport()
  4671.     {
  4672.         return $this->xcPendingExport;
  4673.     }
  4675.     /**
  4676.      * Return BackorderCompetitors
  4677.      *
  4678.      * @return ArrayCollection
  4679.      */
  4680.     public function getBackorderCompetitors()
  4681.     {
  4682.         return $this->backorderCompetitors;
  4683.     }
  4685.     /**
  4686.      * Set BackorderCompetitors
  4687.      *
  4688.      * @param Order[] $backorderCompetitors
  4689.      *
  4690.      * @return $this
  4691.      */
  4692.     public function setBackorderCompetitors($backorderCompetitors)
  4693.     {
  4694.         $this->backorderCompetitors = $backorderCompetitors;
  4695.         return $this;
  4696.     }
  4698.     /**
  4699.      * Get total
  4700.      *
  4701.      * @return float
  4702.      */
  4703.     public function getTotal()
  4704.     {
  4705.         return $this->total;
  4706.     }
  4708.     /**
  4709.      * Get subtotal
  4710.      *
  4711.      * @return float
  4712.      */
  4713.     public function getSubtotal()
  4714.     {
  4715.         return $this->subtotal;
  4716.     }
  4718.     /**
  4719.      * Get profile
  4720.      *
  4721.      * @return \XLite\Model\Profile
  4722.      */
  4723.     public function getProfile()
  4724.     {
  4725.         return $this->profile;
  4726.     }
  4728.     /**
  4729.      * Get orig_profile
  4730.      *
  4731.      * @return \XLite\Model\Profile
  4732.      */
  4733.     public function getOrigProfile()
  4734.     {
  4735.         return $this->orig_profile;
  4736.     }
  4738.     /**
  4739.      * Get paymentStatus
  4740.      *
  4741.      * @return \XLite\Model\Order\Status\Payment
  4742.      */
  4743.     public function getPaymentStatus()
  4744.     {
  4745.         return $this->paymentStatus;
  4746.     }
  4748.     /**
  4749.      * Get shippingStatus
  4750.      *
  4751.      * @return \XLite\Model\Order\Status\Shipping
  4752.      */
  4753.     public function getShippingStatus()
  4754.     {
  4755.         return $this->shippingStatus;
  4756.     }
  4758.     /**
  4759.      * Add details
  4760.      *
  4761.      * @param \XLite\Model\OrderDetail $details
  4762.      * @return Order
  4763.      */
  4764.     public function addDetails(\XLite\Model\OrderDetail $details)
  4765.     {
  4766.         $this->details[] = $details;
  4767.         return $this;
  4768.     }
  4770.     /**
  4771.      * Get details
  4772.      *
  4773.      * @return \Doctrine\Common\Collections\Collection|\XLite\Model\OrderDetail[]
  4774.      */
  4775.     public function getDetails()
  4776.     {
  4777.         return $this->details;
  4778.     }
  4780.     /**
  4781.      * Add trackingNumbers
  4782.      *
  4783.      * @param \XLite\Model\OrderTrackingNumber $trackingNumbers
  4784.      * @return Order
  4785.      */
  4786.     public function addTrackingNumbers(\XLite\Model\OrderTrackingNumber $trackingNumbers)
  4787.     {
  4788.         $this->trackingNumbers[] = $trackingNumbers;
  4789.         return $this;
  4790.     }
  4792.     /**
  4793.      * Get trackingNumbers
  4794.      *
  4795.      * @return \Doctrine\Common\Collections\Collection
  4796.      */
  4797.     public function getTrackingNumbers()
  4798.     {
  4799.         return $this->trackingNumbers;
  4800.     }
  4802.     /**
  4803.      * Add events
  4804.      *
  4805.      * @param \XLite\Model\OrderHistoryEvents $events
  4806.      * @return Order
  4807.      */
  4808.     public function addEvents(\XLite\Model\OrderHistoryEvents $events)
  4809.     {
  4810.         $this->events[] = $events;
  4811.         return $this;
  4812.     }
  4814.     /**
  4815.      * Get events
  4816.      *
  4817.      * @return \Doctrine\Common\Collections\Collection
  4818.      */
  4819.     public function getEvents()
  4820.     {
  4821.         return $this->events;
  4822.     }
  4824.     /**
  4825.      * Add item
  4826.      *
  4827.      * @param \XLite\Model\OrderItem $item
  4828.      * @return Order
  4829.      */
  4830.     public function addItems(\XLite\Model\OrderItem $item)
  4831.     {
  4832.         $this->items[] = $item;
  4833.         return $this;
  4834.     }
  4836.     /**
  4837.      * Get items
  4838.      *
  4839.      * @return list<OrderItem>
  4840.      */
  4841.     public function getItems()
  4842.     {
  4843.         return $this->items;
  4844.     }
  4846.     /**
  4847.      * Add surcharges
  4848.      *
  4849.      * @param \XLite\Model\Order\Surcharge $surcharges
  4850.      * @return Order
  4851.      */
  4852.     public function addSurcharges(\XLite\Model\Order\Surcharge $surcharges)
  4853.     {
  4854.         $this->surcharges[] = $surcharges;
  4855.         return $this;
  4856.     }
  4858.     /**
  4859.      * Get surcharges
  4860.      *
  4861.      * @return \Doctrine\Common\Collections\Collection
  4862.      */
  4863.     public function getSurcharges()
  4864.     {
  4865.         return $this->surcharges;
  4866.     }
  4868.     /**
  4869.      * Add payment_transactions
  4870.      *
  4871.      * @param \XLite\Model\Payment\Transaction $paymentTransactions
  4872.      * @return Order
  4873.      */
  4874.     public function addPaymentTransactions(\XLite\Model\Payment\Transaction $paymentTransactions)
  4875.     {
  4876.         $this->payment_transactions[] = $paymentTransactions;
  4877.         return $this;
  4878.     }
  4880.     /**
  4881.      * Get payment_transactions
  4882.      *
  4883.      * @return \Doctrine\Common\Collections\Collection|\XLite\Model\Payment\Transaction[]
  4884.      */
  4885.     public function getPaymentTransactions()
  4886.     {
  4887.         $result = $this->payment_transactions;
  4889.         $compare = static function ($a, $b) {
  4890.             /** @var \XLite\Model\Payment\Transaction $a */
  4891.             /** @var \XLite\Model\Payment\Transaction $b */
  4892.             return ($a->getTransactionId() < $b->getTransactionId()) ? -1 : 1;
  4893.         };
  4895.         if ($result instanceof \Doctrine\Common\Collections\Collection) {
  4896.             $iterator = $result->getIterator();
  4897.             $iterator->uasort($compare);
  4899.             foreach ($iterator as $key => $item) {
  4900.                 $result->set($key, $item);
  4901.             }
  4902.         } elseif (is_array($result)) {
  4903.             uasort($result, $compare);
  4904.         }
  4906.         return $result;
  4907.     }
  4909.     /**
  4910.      * Set currency
  4911.      *
  4912.      * @param \XLite\Model\Currency $currency
  4913.      * @return Order
  4914.      */
  4915.     public function setCurrency(\XLite\Model\Currency $currency = null)
  4916.     {
  4917.         $this->currency = $currency;
  4918.         return $this;
  4919.     }
  4921.     /**
  4922.      * Get currency
  4923.      *
  4924.      * @return \XLite\Model\Currency
  4925.      */
  4926.     public function getCurrency()
  4927.     {
  4928.         return $this->currency;
  4929.     }
  4931.     /**
  4932.      * Check - block Paid is visible or not
  4933.      *
  4934.      * @return boolean
  4935.      */
  4936.     protected function blockPaidIsVisible()
  4937.     {
  4938.         return $this->getPaidTotal() > 0
  4939.             && $this->getOpenTotal() >= 0;
  4940.     }
  4942.     /**
  4943.      * Remember last shipping id
  4944.      *
  4945.      * @return bool
  4946.      */
  4947.     public function updateEmptyShippingID()
  4948.     {
  4949.         if (!$this->getShippingId() && $this->getProfile() && $this->getLastShippingId()) {
  4950.             $this->setShippingId($this->getLastShippingId());
  4951.             return true;
  4952.         }
  4954.         return false;
  4955.     }
  4957.     public function getSalesChannelBackground(): ?string
  4958.     {
  4959.         return '#F5F5F5';
  4960.     }
  4962.     public function hasZeroCostRate()
  4963.     {
  4964.         $currency = $this->getCurrency();
  4965.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  4966.         $rates = $modifier->getRates();
  4968.         foreach ($rates as $rate) {
  4969.             if ($rate->isZeroCost($currency)) {
  4970.                 return true;
  4971.             }
  4972.         }
  4974.         return false;
  4975.     }
  4977.     public function isCurrentRateZero()
  4978.     {
  4979.         $currency = $this->getCurrency();
  4980.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  4981.         $rates = $modifier->getRates();
  4983.         $currentRate = $modifier->getSelectedRate() ?? reset($rates);
  4984.         if ($currentRate->isZeroCost($currency)) {
  4985.             return true;
  4986.         }
  4988.         return false;
  4989.     }
  4991.     /**
  4992.      * Show free shipping note
  4993.      *
  4994.      * @return boolean
  4995.      */
  4996.     public function showFreeShippingNote()
  4997.     {
  4998.         if (!\XLite\Core\Config::getInstance()->General->display_free_shipping_note) {
  4999.             return false;
  5000.         }
  5002.         if ($this->hasZeroCostRate() && !$this->isCurrentRateZero()) {
  5003.             return true;
  5004.         }
  5006.         return false;
  5007.     }
  5008. }