classes/XLite/Model/Order.php line 82

Open in your IDE?
  1. <?php
  3. /**
  4.  * Copyright (c) 2001-present X-Cart Holdings LLC. 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;
  23. use XLite\Model\Shipping\Method;
  25. /**
  26.  * Class represents an order
  27.  *
  28.  * @ORM\Entity
  29.  * @ORM\Table  (name="orders",
  30.  *      indexes={
  31.  *          @ORM\Index (name="date", columns={"date"}),
  32.  *          @ORM\Index (name="total", columns={"total"}),
  33.  *          @ORM\Index (name="subtotal", columns={"subtotal"}),
  34.  *          @ORM\Index (name="tracking", columns={"tracking"}),
  35.  *          @ORM\Index (name="payment_status", columns={"payment_status_id"}),
  36.  *          @ORM\Index (name="shipping_status", columns={"shipping_status_id"}),
  37.  *          @ORM\Index (name="shipping_id", columns={"shipping_id"}),
  38.  *          @ORM\Index (name="lastRenewDate", columns={"lastRenewDate"}),
  39.  *          @ORM\Index (name="orderNumber", columns={"orderNumber"}),
  40.  *          @ORM\Index (name="is_order", columns={"is_order"}),
  41.  *          @ORM\Index (name="xcPendingExport", columns={"xcPendingExport"})
  42.  *      }
  43.  * )
  44.  *
  45.  * @ ClearDiscriminatorCondition
  46.  * @ORM\InheritanceType       ("SINGLE_TABLE")
  47.  * @ORM\DiscriminatorColumn   (name="is_order", type="integer", length=1)
  48.  * @ORM\DiscriminatorMap      ({1 = "XLite\Model\Order", 0 = "XLite\Model\Cart"})
  49.  * @ApiPlatform\ApiResource(
  50.  *     output=Output::class,
  51.  *     itemOperations={
  52.  *          "get"={
  53.  *              "method"="GET",
  54.  *              "path"="/orders/{id}.{_format}",
  55.  *              "identifiers"={"id"},
  56.  *              "requirements"={"id"="\d+"},
  57.  *              "openapi_context"={
  58.  *                  "summary"="Retrieve an order by order id",
  59.  *                  "parameters"={
  60.  *                      {"name"="id", "in"="path", "required"=true, "schema"={"type"="integer"}}
  61.  *                  }
  62.  *             },
  63.  *          },
  64.  *          "get_by_number"={
  65.  *              "method"="GET",
  66.  *              "path"="/orders/by_number/{orderNumber}.{_format}",
  67.  *              "requirements"={"orderNumber"="\w+"},
  68.  *              "identifiers"={"orderNumber"},
  69.  *              "openapi_context"={
  70.  *                  "summary"="Retrieve an order by order number",
  71.  *                  "parameters"={
  72.  *                      {"name"="orderNumber", "in"="path", "required"=true, "schema"={"type"="string"}}
  73.  *                  }
  74.  *             },
  75.  *          }
  76.  *     },
  77.  *     collectionOperations={
  78.  *          "get"={
  79.  *              "method"="GET",
  80.  *              "path"="/orders.{_format}",
  81.  *              "identifiers"={"id"}
  82.  *          }
  83.  *     }
  84.  * )
  85.  * @ApiPlatform\ApiFilter(IntegerDateFilter::class, properties={"date", "lastRenewDate"})
  86.  * @ApiPlatform\ApiFilter(OrderFilter::class, properties={"date","lastRenewDate"}, arguments={"orderParameterName"="order"})
  87.  * @ApiPlatform\ApiFilter(SearchFilter::class, properties={"paymentStatus.code"="exact", "shippingStatus.code"="exact", "profile.login"="partial"})
  88.  */
  89. class Order extends \XLite\Model\Base\SurchargeOwner
  90. {
  91.     use \XLite\Core\Cache\ExecuteCachedTrait;
  93.     /**
  94.      * Order total that is financially declared as zero (null)
  95.      */
  96.     public const ORDER_ZERO = 0.00001;
  98.     /**
  99.      * Add item error codes
  100.      */
  101.     public const NOT_VALID_ERROR = 'notValid';
  103.     public const DEFAULT_SALES_CHANNEL = 'Online store';
  105.     /**
  106.      * Order unique id
  107.      *
  108.      * @var mixed
  109.      *
  110.      * @ORM\Id
  111.      * @ORM\GeneratedValue (strategy="AUTO")
  112.      * @ORM\Column         (type="integer")
  113.      */
  114.     protected $order_id;
  116.     /**
  117.      * Order unique id
  118.      *
  119.      * @var string|null
  120.      *
  121.      * @ORM\Column (type="string", length=36, nullable=true, options={"fixed": true})
  122.      */
  123.     protected ?string $public_id = null;
  125.     /**
  126.      * Order profile
  127.      *
  128.      * @var \XLite\Model\Profile
  129.      *
  130.      * @ORM\OneToOne   (targetEntity="XLite\Model\Profile", cascade={"merge","detach","persist"})
  131.      * @ORM\JoinColumn (name="profile_id", referencedColumnName="profile_id", onDelete="CASCADE")
  132.      */
  133.     protected $profile;
  135.     /**
  136.      * Original profile
  137.      *
  138.      * @var \XLite\Model\Profile
  139.      *
  140.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Profile", cascade={"merge","detach","persist"})
  141.      * @ORM\JoinColumn (name="orig_profile_id", referencedColumnName="profile_id", onDelete="SET NULL")
  142.      */
  143.     protected $orig_profile;
  145.     /**
  146.      * Shipping method unique id
  147.      *
  148.      * @var integer
  149.      *
  150.      * @ORM\Column (type="integer")
  151.      */
  152.     protected $shipping_id = 0;
  154.     /**
  155.      * Shipping method name
  156.      *
  157.      * @var string
  158.      *
  159.      * @ORM\Column (type="string", nullable=true)
  160.      */
  161.     protected $shipping_method_name = '';
  163.     /**
  164.      * Payment method name
  165.      *
  166.      * @var string
  167.      *
  168.      * @ORM\Column (type="string", nullable=true)
  169.      */
  170.     protected $payment_method_name = '';
  172.     /**
  173.      * @var string
  174.      *
  175.      * @ORM\Column (type="string", nullable=true)
  176.      */
  177.     protected $salesChannel = self::DEFAULT_SALES_CHANNEL;
  179.     /**
  180.      * Shipping tracking code
  181.      *
  182.      * @var string
  183.      *
  184.      * @ORM\Column (type="string", length=32)
  185.      */
  186.     protected $tracking = '';
  188.     /**
  189.      * Order creation timestamp
  190.      *
  191.      * @var integer
  192.      *
  193.      * @ORM\Column (type="integer")
  194.      */
  195.     protected $date;
  197.     /**
  198.      * Last order renew date
  199.      *
  200.      * @var integer
  201.      *
  202.      * @ORM\Column (type="integer")
  203.      */
  204.     protected $lastRenewDate = 0;
  206.     /**
  207.      * Payment status
  208.      *
  209.      * @var \XLite\Model\Order\Status\Payment
  210.      *
  211.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Order\Status\Payment")
  212.      * @ORM\JoinColumn (name="payment_status_id", referencedColumnName="id", onDelete="SET NULL")
  213.      */
  214.     protected $paymentStatus;
  216.     /**
  217.      * Shipping status
  218.      *
  219.      * @var \XLite\Model\Order\Status\Shipping
  220.      *
  221.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Order\Status\Shipping")
  222.      * @ORM\JoinColumn (name="shipping_status_id", referencedColumnName="id", onDelete="SET NULL")
  223.      */
  224.     protected $shippingStatus;
  226.     /**
  227.      * Customer notes
  228.      *
  229.      * @var string
  230.      *
  231.      * @ORM\Column (type="text")
  232.      */
  233.     protected $notes = '';
  235.     /**
  236.      * Admin notes
  237.      *
  238.      * @var string
  239.      *
  240.      * @ORM\Column (type="text")
  241.      */
  242.     protected $adminNotes = '';
  244.     /**
  245.      * Order details
  246.      *
  247.      * @var \Doctrine\Common\Collections\Collection
  248.      *
  249.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderDetail", mappedBy="order", cascade={"all"})
  250.      * @ORM\OrderBy   ({"name" = "ASC"})
  251.      */
  252.     protected $details;
  254.     /**
  255.      * Order tracking numbers
  256.      *
  257.      * @var \Doctrine\Common\Collections\Collection
  258.      *
  259.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderTrackingNumber", mappedBy="order", cascade={"all"})
  260.      */
  261.     protected $trackingNumbers;
  263.     /**
  264.      * Order events queue
  265.      *
  266.      * @var \Doctrine\Common\Collections\Collection
  267.      *
  268.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderHistoryEvents", mappedBy="order", cascade={"all"})
  269.      */
  270.     protected $events;
  272.     /**
  273.      * Order items
  274.      *
  275.      * @var \Doctrine\Common\Collections\Collection|\XLite\Model\OrderItem[]
  276.      *
  277.      * @ORM\OneToMany (targetEntity="XLite\Model\OrderItem", mappedBy="order", cascade={"all"})
  278.      */
  279.     protected $items;
  281.     /**
  282.      * Order surcharges
  283.      *
  284.      * @var \Doctrine\Common\Collections\Collection
  285.      *
  286.      * @ORM\OneToMany (targetEntity="XLite\Model\Order\Surcharge", mappedBy="owner", cascade={"all"})
  287.      * @ORM\OrderBy   ({"weight" = "ASC", "id" = "ASC"})
  288.      */
  289.     protected $surcharges;
  291.     /**
  292.      * Payment transactions
  293.      *
  294.      * @var \Doctrine\Common\Collections\Collection
  295.      *
  296.      * @ORM\OneToMany (targetEntity="XLite\Model\Payment\Transaction", mappedBy="order", cascade={"all"})
  297.      */
  298.     protected $payment_transactions;
  300.     /**
  301.      * Currency
  302.      *
  303.      * @var \XLite\Model\Currency
  304.      *
  305.      * @ORM\ManyToOne  (targetEntity="XLite\Model\Currency", inversedBy="orders", cascade={"merge","detach"})
  306.      * @ORM\JoinColumn (name="currency_id", referencedColumnName="currency_id", onDelete="CASCADE")
  307.      */
  308.     protected $currency;
  310.     /**
  311.      * Unique order identificator (it is working for orders only, not for cart entities)
  312.      *
  313.      * @var integer
  314.      *
  315.      * @ORM\Column (type="string", length=255, nullable=true)
  316.      */
  317.     protected $orderNumber;
  319.     /**
  320.      * Recent flag: true if order's statuses were not changed manually by an administrator, otherwise - false
  321.      *
  322.      * @var boolean
  323.      *
  324.      * @ORM\Column (type="boolean")
  325.      */
  326.     protected $recent = true;
  328.     /**
  329.      * @var string
  330.      *
  331.      * @ORM\Column (type="string", length=255, nullable=true)
  332.      */
  333.     protected $stockStatus = '';
  335.     /**
  336.      * 'Add item' error code
  337.      *
  338.      * @var string
  339.      */
  340.     protected $addItemError;
  342.     /**
  343.      * Order previous payment status
  344.      *
  345.      * @var \XLite\Model\Order\Status\Payment
  346.      */
  347.     protected $oldPaymentStatus;
  349.     /**
  350.      * Flag: true - order is prepared for removing
  351.      *
  352.      * @var boolean
  353.      */
  354.     protected $isRemoving = false;
  356.     /**
  357.      * Order previous shipping status
  358.      *
  359.      * @var \XLite\Model\Order\Status\Shipping
  360.      */
  361.     protected $oldShippingStatus;
  363.     /**
  364.      * Modifiers (cache)
  365.      *
  366.      * @var \XLite\DataSet\Collection\OrderModifier
  367.      */
  368.     protected $modifiers;
  370.     /**
  371.      * Shipping carrier object cache.
  372.      * Use $this->getShippingProcessor() method to retrieve.
  373.      *
  374.      * @var \XLite\Model\Shipping\Processor\AProcessor
  375.      */
  376.     protected $shippingProcessor;
  378.     /**
  379.      * Check if notification sent by any status handler to avoid extra 'changed' notification
  380.      *
  381.      * @var boolean
  382.      */
  383.     protected $isNotificationSent = false;
  385.     /**
  386.      * Flag: Ignore sending notifications to a customer if true
  387.      *
  388.      * @var boolean
  389.      */
  390.     protected $ignoreCustomerNotifications = false;
  392.     /**
  393.      * Flag: is email notifications are allowed for the order
  394.      *
  395.      * @var boolean
  396.      */
  397.     protected $isNotificationsAllowedFlag = true;
  399.     /**
  400.      * Check status is set or not
  401.      *
  402.      * @var boolean
  403.      */
  404.     protected $statusIsSet = false;
  406.     /**
  407.      * Payment transaction sums
  408.      *
  409.      * @var array
  410.      */
  411.     protected $paymentTransactionSums;
  413.     /**
  414.      * Source address
  415.      *
  416.      * @var \XLite\Model\Address
  417.      */
  418.     protected $sourceAddress;
  420.     /**
  421.      * Flag to exporting entities
  422.      *
  423.      * @var boolean
  424.      *
  425.      * @ORM\Column (type="boolean")
  426.      */
  427.     protected $xcPendingExport = false;
  429.     /**
  430.      * Profiles
  431.      *
  432.      * @var ArrayCollection
  433.      *
  434.      * @ORM\ManyToMany (targetEntity="XLite\Model\Order")
  435.      * @ORM\JoinTable  (
  436.      *      name="order_backorder_competitors",
  437.      *      joinColumns={@ORM\JoinColumn(name="id", referencedColumnName="order_id", onDelete="CASCADE")},
  438.      *      inverseJoinColumns={@ORM\JoinColumn(name="competitor_id", referencedColumnName="order_id", onDelete="CASCADE")}
  439.      * )
  440.      */
  441.     protected $backorderCompetitors;
  443.     protected $backorderProductAmounts = [];
  445.     /**
  446.      * If entity temporary
  447.      *
  448.      * @var bool
  449.      */
  450.     protected $temporary = false;
  452.     /**
  453.      * @return boolean
  454.      */
  455.     public function isTemporary()
  456.     {
  457.         return $this->temporary;
  458.     }
  460.     /**
  461.      * @param boolean $temporary
  462.      */
  463.     public function setTemporary($temporary)
  464.     {
  465.         $this->temporary = $temporary;
  466.     }
  468.     /**
  469.      * Flag if cart become order in current runtime
  470.      *
  471.      * @var bool
  472.      */
  473.     protected $justClosed = false;
  475.     /**
  476.      * @return bool
  477.      */
  478.     public function isJustClosed()
  479.     {
  480.         return $this->justClosed;
  481.     }
  483.     /**
  484.      * @param bool $justClosed
  485.      */
  486.     protected function setJustClosed($justClosed)
  487.     {
  488.         $this->justClosed = $justClosed;
  489.     }
  491.     /**
  492.      * Add item to order
  493.      *
  494.      * @param \XLite\Model\OrderItem $newItem Item to add
  495.      *
  496.      * @return boolean
  497.      */
  498.     public function addItem(\XLite\Model\OrderItem $newItem)
  499.     {
  500.         $result = false;
  502.         if ($newItem->isValid() && $newItem->isConfigured()) {
  503.             $this->addItemError = null;
  504.             $newItem->setOrder($this);
  506.             $item = $this->getItemByItem($newItem);
  508.             $warningText = '';
  510.             if ($item) {
  511.                 $warningText = $item->getAmountWarning(
  512.                     $item->getAmount() + $newItem->getAmount()
  513.                 );
  515.                 $item->setAmount($item->getAmount() + $newItem->getAmount());
  516.                 $item->refreshUpdateDate();
  517.             } else {
  518.                 $newItem->refreshUpdateDate();
  519.                 $this->addItems($newItem);
  520.             }
  522.             $result = $warningText === '';
  524.             if ($warningText !== '') {
  525.                 \XLite\Core\TopMessage::addWarning($warningText);
  526.             }
  527.         } else {
  528.             $this->addItemError = static::NOT_VALID_ERROR;
  529.         }
  531.         return $result;
  532.     }
  534.     /**
  535.      * Remove item from order
  536.      *
  537.      * @param \XLite\Model\OrderItem $item
  538.      */
  539.     public function removeItem(\XLite\Model\OrderItem $item)
  540.     {
  541.         if ($item->getAmount() > 1) {
  542.             $item->setAmount($item->getAmount() - 1);
  543.         } else {
  544.             $this->getItems()->removeElement($item);
  545.             \XLite\Core\Database::getEM()->remove($item);
  546.         }
  547.     }
  549.     /**
  550.      * Get 'Add item' error code
  551.      *
  552.      * @return string|void
  553.      */
  554.     public function getAddItemError()
  555.     {
  556.         return $this->addItemError;
  557.     }
  559.     /**
  560.      * Get item from order by another item
  561.      *
  562.      * @param \XLite\Model\OrderItem $item Another item
  563.      *
  564.      * @return \XLite\Model\OrderItem|void
  565.      */
  566.     public function getItemByItem(\XLite\Model\OrderItem $item)
  567.     {
  568.         return $this->getItemByItemKey($item->getKey());
  569.     }
  571.     /**
  572.      * Get item from order by item key
  573.      *
  574.      * @param string $key Item key
  575.      *
  576.      * @return \XLite\Model\OrderItem|void
  577.      */
  578.     public function getItemByItemKey($key)
  579.     {
  580.         $items = $this->getItems();
  582.         return \Includes\Utils\ArrayManager::findValue(
  583.             $items,
  584.             [$this, 'checkItemKeyEqual'],
  585.             $key
  586.         );
  587.     }
  589.     /**
  590.      * Get item from order by item  id
  591.      *
  592.      * @param integer $itemId Item id
  593.      *
  594.      * @return \XLite\Model\OrderItem|void
  595.      */
  596.     public function getItemByItemId($itemId)
  597.     {
  598.         $items = $this->getItems();
  600.         return \Includes\Utils\ArrayManager::findValue(
  601.             $items,
  602.             [$this, 'checkItemIdEqual'],
  603.             $itemId
  604.         );
  605.     }
  607.     /**
  608.      * Find items by product ID
  609.      *
  610.      * @param integer $productId Product ID to use
  611.      *
  612.      * @return array
  613.      */
  614.     public function getItemsByProductId($productId)
  615.     {
  616.         $items = $this->getItems();
  618.         return \Includes\Utils\ArrayManager::filter(
  619.             $items,
  620.             [$this, 'isItemProductIdEqual'],
  621.             $productId
  622.         );
  623.     }
  625.     /**
  626.      * Normalize items
  627.      *
  628.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  629.      *
  630.      * @return void
  631.      */
  632.     public function normalizeItems()
  633.     {
  634.         // Normalize by key
  635.         $keys = [];
  637.         foreach ($this->getItems() as $item) {
  638.             $key = $item->getKey();
  639.             if (isset($keys[$key])) {
  640.                 $keys[$key]->setAmount($keys[$key]->getAmount() + $item->getAmount());
  641.                 $this->getItems()->removeElement($item);
  643.                 if (\XLite\Core\Database::getEM()->contains($item)) {
  644.                     \XLite\Core\Database::getEM()->remove($item);
  645.                 }
  646.             } else {
  647.                 $keys[$key] = $item;
  648.             }
  649.         }
  651.         unset($keys);
  653.         // Remove invalid items
  654.         foreach ($this->getItems() as $item) {
  655.             if (!$item->isValid()) {
  656.                 $this->getItems()->removeElement($item);
  657.                 if (\XLite\Core\Database::getEM()->contains($item)) {
  658.                     \XLite\Core\Database::getEM()->remove($item);
  659.                 }
  660.             }
  661.         }
  662.     }
  664.     /**
  665.      * Return items number
  666.      *
  667.      * @return integer
  668.      */
  669.     public function countItems()
  670.     {
  671.         return count($this->getItems());
  672.     }
  674.     /**
  675.      * Return order items total quantity
  676.      *
  677.      * @return integer
  678.      */
  679.     public function countQuantity()
  680.     {
  681.         $quantity = 0;
  683.         foreach ($this->getItems() as $item) {
  684.             $quantity += $item->getAmount();
  685.         }
  687.         return $quantity;
  688.     }
  690.     /**
  691.      * Get failure reason
  692.      *
  693.      * @return string
  694.      */
  695.     public function getFailureReason()
  696.     {
  697.         $transactions = $this->getPaymentTransactions()->getValues();
  698.         /** @var \XLite\Model\Payment\Transaction $transaction */
  699.         foreach (array_reverse($transactions) as $transaction) {
  700.             if ($transaction->isFailed()) {
  701.                 if ($transaction->getNote() && $transaction->getNote() !== Transaction::getDefaultFailedReason()) {
  702.                     return $transaction->getNote();
  703.                 }
  705.                 $reason = $transaction->getDataCell('status');
  707.                 if ($reason && $reason->getValue()) {
  708.                     return $reason->getValue();
  709.                 }
  710.             }
  711.         }
  713.         return null;
  714.     }
  716.     /**
  717.      * Checks whether the shopping cart/order is empty
  718.      *
  719.      * @return boolean
  720.      */
  721.     public function isEmpty()
  722.     {
  723.         return 0 >= $this->countItems();
  724.     }
  726.     /**
  727.      * Check order subtotal
  728.      *
  729.      * @return boolean
  730.      */
  731.     public function isMinOrderAmountError()
  732.     {
  733.         return $this->getSubtotal() < \XLite\Core\Config::getInstance()->General->minimal_order_amount;
  734.     }
  736.     /**
  737.      * Check order subtotal
  738.      *
  739.      * @return boolean
  740.      */
  741.     public function isMaxOrderAmountError()
  742.     {
  743.         return $this->getSubtotal() > \XLite\Core\Config::getInstance()->General->maximal_order_amount;
  744.     }
  746.     /**
  747.      * Return printable order number
  748.      *
  749.      * @return string
  750.      */
  751.     public function getPrintableOrderNumber()
  752.     {
  753.         $orderNumber = (string) $this->getOrderNumber();
  755.         return '#' . str_repeat('0', 5 - min(5, strlen($orderNumber))) . $orderNumber;
  756.     }
  758.     /**
  759.      * Check - is order processed or not
  760.      *
  761.      * @return boolean
  762.      */
  763.     public function isProcessed()
  764.     {
  765.         return in_array(
  766.             $this->getPaymentStatusCode(),
  767.             [
  768.                 \XLite\Model\Order\Status\Payment::STATUS_PART_PAID,
  769.                 \XLite\Model\Order\Status\Payment::STATUS_PAID,
  770.             ],
  771.             true
  772.         );
  773.     }
  775.     /**
  776.      * Check - is order queued or not
  777.      *
  778.      * @return boolean
  779.      */
  780.     public function isQueued()
  781.     {
  782.         return $this->getPaymentStatusCode() === \XLite\Model\Order\Status\Payment::STATUS_QUEUED;
  783.     }
  785.     /**
  786.      * Check item amounts
  787.      *
  788.      * @return array
  789.      */
  790.     public function getItemsWithWrongAmounts()
  791.     {
  792.         $items = [];
  793.         foreach ($this->getItems() as $item) {
  794.             if ($item->hasWrongAmount()) {
  795.                 $items[] = $item;
  796.             }
  797.         }
  799.         return $items;
  800.     }
  802.     /**
  803.      * Set profile
  804.      *
  805.      * @param \XLite\Model\Profile $profile Profile OPTIONAL
  806.      *
  807.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  808.      *
  809.      * @return void
  810.      */
  811.     public function setProfile(\XLite\Model\Profile $profile = null)
  812.     {
  813.         if (
  814.             $this->getProfile()
  815.             && $this->getProfile()->getOrder()
  816.             && (!$profile || $this->getProfile()->getProfileId() != $profile->getProfileId())
  817.         ) {
  818.             $this->getProfile()->setOrder(null);
  819.             if ($this->getProfile()->getAnonymous() && $profile && !$profile->getAnonymous()) {
  820.                 \XLite\Core\Database::getEM()->remove($this->getProfile());
  821.             }
  822.         }
  824.         $this->profile = $profile;
  825.     }
  827.     /**
  828.      * Set original profile
  829.      * FIXME: is it really needed?
  830.      *
  831.      * @param \XLite\Model\Profile $profile Profile OPTIONAL
  832.      *
  833.      * @return void
  834.      */
  835.     public function setOrigProfile(\XLite\Model\Profile $profile = null)
  836.     {
  837.         if (
  838.             $this->getOrigProfile()
  839.             && $this->getOrigProfile()->getOrder()
  840.             && (!$profile || $this->getOrigProfile()->getProfileId() != $profile->getProfileId())
  841.             && (!$this->getProfile() || $this->getOrigProfile()->getProfileId() != $this->getProfile()->getProfileId())
  842.         ) {
  843.             $this->getOrigProfile()->setOrder(null);
  844.         }
  846.         $this->orig_profile = $profile;
  847.     }
  849.     /**
  850.      * Set profile copy
  851.      *
  852.      * @param \XLite\Model\Profile $profile Profile
  853.      *
  854.      * @return void
  855.      */
  856.     public function setProfileCopy(\XLite\Model\Profile $profile)
  857.     {
  858.         // Set profile as original profile
  859.         $this->setOrigProfile($profile);
  861.         // Clone profile and set as order profile
  862.         $clonedProfile = $profile->cloneEntity();
  863.         $this->setProfile($clonedProfile);
  864.         $clonedProfile->setOrder($this);
  865.     }
  867.     // {{{ Clone
  869.     /**
  870.      * clone Order as temporary
  871.      *
  872.      * @return \XLite\Model\Order
  873.      */
  874.     public function cloneOrderAsTemporary()
  875.     {
  876.         $isTemporary = $this->isTemporary();
  877.         $this->setTemporary(true);
  878.         $result = $this->cloneEntity();
  879.         $result->setOrderNumber(null);
  880.         $result->setIsNotificationsAllowedFlag(null);
  881.         $result->setTemporary(true);
  882.         $this->setTemporary($isTemporary);
  884.         return $result;
  885.     }
  887.     /**
  888.      * Clone order and all related data
  889.      *
  890.      * @return \XLite\Model\Order
  891.      */
  892.     public function cloneEntity()
  893.     {
  894.         // Clone order
  895.         $newOrder = parent::cloneEntity();
  897.         $this->cloneEntityAssignOrderNumber($newOrder);
  898.         $this->cloneEntityProfile($newOrder);
  899.         $this->cloneEntityCurrency($newOrder);
  900.         $this->cloneEntityOrderStatuses($newOrder);
  901.         $this->cloneOrderItems($newOrder);
  902.         $this->cloneEntityOrderDetails($newOrder);
  903.         $this->cloneEntityTrackingNumbers($newOrder);
  904.         $this->cloneEntityEvents($newOrder);
  905.         $this->cloneEntitySurcharges($newOrder);
  906.         $this->cloneEntityPaymentTransactions($newOrder);
  908.         return $newOrder;
  909.     }
  911.     /**
  912.      * @return string|null
  913.      */
  914.     public function getStockStatus()
  915.     {
  916.         return $this->stockStatus;
  917.     }
  919.     /**
  920.      * @param string|null $stockStatus
  921.      */
  922.     public function setStockStatus($stockStatus)
  923.     {
  924.         $this->stockStatus = $stockStatus;
  925.     }
  927.     /**
  928.      * Assign order number for cloned entity
  929.      *
  930.      * @param \XLite\Model\Order $newOrder
  931.      * @throws \Doctrine\ORM\ORMException
  932.      */
  933.     protected function cloneEntityAssignOrderNumber($newOrder)
  934.     {
  935.         if ($this->getOrderNumber() && !$this->isTemporary()) {
  936.             $newOrder->setOrderNumber(
  937.                 \XLite\Core\Database::getRepo('XLite\Model\Order')->findNextOrderNumber()
  938.             );
  939.         }
  940.     }
  942.     /**
  943.      * Assign profiles for cloned entity
  944.      *
  945.      * @param \XLite\Model\Order $newOrder
  946.      */
  947.     protected function cloneEntityProfile($newOrder)
  948.     {
  949.         $newOrder->setOrigProfile($this->getOrigProfile());
  951.         if ($this->getProfile()) {
  952.             $clonedProfile = $this->getProfile()->cloneEntity();
  953.             $newOrder->setProfile($clonedProfile);
  954.             $clonedProfile->setOrder($newOrder);
  955.         }
  956.     }
  958.     /**
  959.      * Assign currency for cloned entity
  960.      *
  961.      * @param \XLite\Model\Order $newOrder
  962.      */
  963.     protected function cloneEntityCurrency($newOrder)
  964.     {
  965.         $newOrder->setCurrency($this->getCurrency());
  966.     }
  968.     /**
  969.      * Assign order statuses for cloned entity
  970.      *
  971.      * @param \XLite\Model\Order $newOrder
  972.      */
  973.     protected function cloneEntityOrderStatuses($newOrder)
  974.     {
  975.         $newOrder->setPaymentStatus($this->getPaymentStatus());
  976.         $newOrder->setShippingStatus($this->getShippingStatus());
  977.     }
  979.     /**
  980.      * Assign order details for cloned entity
  981.      *
  982.      * @param \XLite\Model\Order $newOrder
  983.      */
  984.     protected function cloneEntityOrderDetails($newOrder)
  985.     {
  986.         foreach ($this->getDetails() as $detail) {
  987.             $clonedDetails = $detail->cloneEntity();
  988.             $newOrder->addDetails($clonedDetails);
  989.             $clonedDetails->setOrder($newOrder);
  990.         }
  991.     }
  993.     /**
  994.      * Assign tracking numbers for cloned entity
  995.      *
  996.      * @param \XLite\Model\Order $newOrder
  997.      */
  998.     protected function cloneEntityTrackingNumbers($newOrder)
  999.     {
  1000.         foreach ($this->getTrackingNumbers() as $tn) {
  1001.             $clonedTN = $tn->cloneEntity();
  1002.             $newOrder->addTrackingNumbers($clonedTN);
  1003.             $clonedTN->setOrder($newOrder);
  1004.         }
  1005.     }
  1007.     /**
  1008.      * Assign events for cloned entity
  1009.      *
  1010.      * @param \XLite\Model\Order $newOrder
  1011.      */
  1012.     protected function cloneEntityEvents($newOrder)
  1013.     {
  1014.         foreach ($this->getEvents() as $event) {
  1015.             $cloned = $event->cloneEntity();
  1016.             $newOrder->addEvents($cloned);
  1017.             $cloned->setOrder($newOrder);
  1018.             $cloned->setAuthor($event->getAuthor());
  1019.         }
  1020.     }
  1022.     /**
  1023.      * Assign surcharges for cloned entity
  1024.      *
  1025.      * @param \XLite\Model\Order $newOrder
  1026.      */
  1027.     protected function cloneEntitySurcharges($newOrder)
  1028.     {
  1029.         foreach ($this->getSurcharges() as $surcharge) {
  1030.             $cloned = $surcharge->cloneEntity();
  1031.             $newOrder->addSurcharges($cloned);
  1032.             $cloned->setOwner($newOrder);
  1033.         }
  1034.     }
  1036.     /**
  1037.      * Assign payment transactions for cloned entity
  1038.      *
  1039.      * @param \XLite\Model\Order $newOrder
  1040.      */
  1041.     protected function cloneEntityPaymentTransactions($newOrder)
  1042.     {
  1043.         foreach ($this->getPaymentTransactions() as $pt) {
  1044.             $cloned = $pt->cloneEntity();
  1045.             $newOrder->addPaymentTransactions($cloned);
  1046.             $cloned->setOrder($newOrder);
  1047.         }
  1048.     }
  1050.     /**
  1051.      * Clone order items
  1052.      *
  1053.      * @param \XLite\Model\Order $newOrder New Order
  1054.      *
  1055.      * @return void
  1056.      */
  1057.     protected function cloneOrderItems($newOrder)
  1058.     {
  1059.         // Clone order items
  1060.         foreach ($this->getItems() as $item) {
  1061.             $clonedItem = $item->cloneEntity();
  1062.             $clonedItem->setOrder($newOrder);
  1063.             $newOrder->addItems($clonedItem);
  1064.         }
  1065.     }
  1067.     // }}}
  1069.     /**
  1070.      * Get shipping method name
  1071.      *
  1072.      * @return string
  1073.      */
  1074.     public function getShippingMethodName()
  1075.     {
  1076.         $shipping = \XLite\Core\Database::getRepo('XLite\Model\Shipping\Method')->find($this->getShippingId());
  1078.         return $shipping ? $shipping->getName() : Method::normalizeName($this->shipping_method_name ?? '');
  1079.     }
  1081.     /**
  1082.      * Get payment method name
  1083.      *
  1084.      * @return string
  1085.      */
  1086.     public function getPaymentMethodName()
  1087.     {
  1088.         $paymentMethod = $this->getPaymentMethod();
  1090.         return $paymentMethod ? $paymentMethod->getName() : $this->payment_method_name;
  1091.     }
  1093.     /**
  1094.      * Get payment method name
  1095.      *
  1096.      * @return string
  1097.      */
  1098.     public function getPaymentMethodId()
  1099.     {
  1100.         $paymentMethod = $this->getPaymentMethod();
  1102.         return $paymentMethod ? $paymentMethod->getMethodId() : null;
  1103.     }
  1105.     /**
  1106.      * Set old payment status of the order (not stored in the DB)
  1107.      *
  1108.      * @param string $paymentStatus Payment status
  1109.      *
  1110.      * @return void
  1111.      */
  1112.     public function setOldPaymentStatus($paymentStatus)
  1113.     {
  1114.         $this->oldPaymentStatus = $paymentStatus;
  1115.     }
  1117.     /**
  1118.      * Set old shipping status of the order (not stored in the DB)
  1119.      *
  1120.      * @param string $shippingStatus Shipping status
  1121.      *
  1122.      * @return void
  1123.      */
  1124.     public function setOldShippingStatus($shippingStatus)
  1125.     {
  1126.         $this->oldShippingStatus = $shippingStatus;
  1127.     }
  1129.     /**
  1130.      * Get items list fingerprint by amount and key
  1131.      *
  1132.      * @return string
  1133.      */
  1134.     public function getItemsAmountKeyFingerprint()
  1135.     {
  1136.         $result = false;
  1138.         if (!$this->isEmpty()) {
  1139.             $items = [];
  1140.             foreach ($this->getItems() as $item) {
  1141.                 $items[] = [
  1142.                     $item->getKey(),
  1143.                     $item->getAmount()
  1144.                 ];
  1145.             }
  1147.             $result = md5(serialize($items));
  1148.         }
  1150.         return $result;
  1151.     }
  1153.     /**
  1154.      * Get items list fingerprint
  1155.      *
  1156.      * @return string
  1157.      */
  1158.     public function getItemsFingerprint()
  1159.     {
  1160.         $result = false;
  1162.         if (!$this->isEmpty()) {
  1163.             $items = [];
  1164.             foreach ($this->getItems() as $item) {
  1165.                 $items[] = [
  1166.                     $item->getItemId(),
  1167.                     $item->getKey(),
  1168.                     $item->getAmount()
  1169.                 ];
  1170.             }
  1172.             $result = md5(serialize($items));
  1173.         }
  1175.         return $result;
  1176.     }
  1178.     /**
  1179.      * Get fingerprint of cart items corresponding to specific product id
  1180.      *
  1181.      * @param integer $productId
  1182.      *
  1183.      * @return string
  1184.      */
  1185.     public function getItemsFingerprintByProductId($productId)
  1186.     {
  1187.         $result = false;
  1189.         if (!$this->isEmpty()) {
  1190.             $items = [];
  1191.             foreach ($this->getItems() as $item) {
  1192.                 if ($item->getObject() && $item->getObject()->getId() == $productId) {
  1193.                     $items[] = [
  1194.                         $item->getItemId(),
  1195.                         $item->getKey(),
  1196.                         $item->getAmount(),
  1197.                     ];
  1198.                 }
  1199.             }
  1201.             $result = md5(serialize($items));
  1202.         }
  1204.         return $result;
  1205.     }
  1207.     /**
  1208.      * Generate a string representation of the order
  1209.      * to send to a payment service
  1210.      *
  1211.      * @return string
  1212.      */
  1213.     public function getDescription()
  1214.     {
  1215.         $result = [];
  1217.         foreach ($this->getItems() as $item) {
  1218.             $result[] = $item->getDescription();
  1219.         }
  1221.         return implode("\n", $result);
  1222.     }
  1224.     /**
  1225.      * Get order fingerprint for event subsystem
  1226.      *
  1227.      * @param array $exclude Exclude kes OPTIONAL
  1228.      *
  1229.      * @return array
  1230.      */
  1231.     public function getEventFingerprint(array $exclude = [])
  1232.     {
  1233.         $keys = array_diff($this->defineFingerprintKeys(), $exclude);
  1235.         $hash = [];
  1236.         foreach ($keys as $key) {
  1237.             $method = 'getFingerprintBy' . ucfirst($key);
  1238.             $hash[$key] = $this->$method();
  1239.         }
  1241.         return $hash;
  1242.     }
  1244.     /**
  1245.      * Returns delivery source address
  1246.      *
  1247.      * @return \XLite\Model\Address
  1248.      */
  1249.     public function getSourceAddress()
  1250.     {
  1251.         if ($this->sourceAddress === null) {
  1252.             $address = new \XLite\Model\Address();
  1254.             $config = $this->getSourceAddressConfiguration();
  1256.             $address->setAddress1($config->origin_address1);
  1257.             $address->setAddress2($config->origin_address2);
  1258.             $address->setAddress3($config->origin_address3);
  1259.             $address->setCity($config->origin_city);
  1260.             $address->setCountryCode($config->origin_country);
  1261.             $address->setName($config->company_name);
  1263.             if ($config->origin_state) {
  1264.                 $address->setStateId($config->origin_state);
  1265.             }
  1267.             if ($config->origin_custom_state) {
  1268.                 $address->setCustomState($config->origin_custom_state);
  1269.             }
  1271.             $address->setZipcode($config->origin_zipcode);
  1272.             $address->setPhone($config->company_phone);
  1274.             $this->sourceAddress = $address;
  1275.         }
  1277.         return $this->sourceAddress;
  1278.     }
  1280.     /**
  1281.      * Returns company configuration for getSourceAddress()
  1282.      *
  1283.      * @return \XLite\Core\ConfigCell
  1284.      */
  1285.     protected function getSourceAddressConfiguration()
  1286.     {
  1287.         return \XLite\Core\Config::getInstance()->Company;
  1288.     }
  1290.     /**
  1291.      * Returns company configuration
  1292.      *
  1293.      * @return \XLite\Core\ConfigCell
  1294.      */
  1295.     public function getCompanyConfiguration()
  1296.     {
  1297.         return \XLite\Core\Config::getInstance()->Company;
  1298.     }
  1300.     /**
  1301.      * Define fingerprint keys
  1302.      *
  1303.      * @return array
  1304.      */
  1305.     protected function defineFingerprintKeys()
  1306.     {
  1307.         return [
  1308.             'items',
  1309.             'itemsCount',
  1310.             'shippingTotal',
  1311.             'total',
  1312.             'shippingMethodId',
  1313.             'freeShippingNote',
  1314.             'paymentMethodId',
  1315.             'shippingMethodsHash',
  1316.             'paymentMethodsHash',
  1317.             'shippingAddressId',
  1318.             'billingAddressId',
  1319.             'shippingAddressFields',
  1320.             'billingAddressFields',
  1321.             'sameAddress',
  1322.         ];
  1323.     }
  1325.     /**
  1326.      * Get fingerprint by 'items' key
  1327.      *
  1328.      * @return array
  1329.      */
  1330.     protected function getFingerprintByItems()
  1331.     {
  1332.         $list = [];
  1334.         foreach ($this->getItems() as $item) {
  1335.             $event = $item->getEventCell();
  1337.             // float is intended here to adopt fractional quantities via modules
  1338.             $event['quantity'] = (float) $item->getAmount();
  1340.             if ($this instanceof \XLite\Model\Cart && $this->isItemLimitReached($item)) {
  1341.                 $event['is_limit'] = 1;
  1342.             }
  1344.             $list[] = $event;
  1345.         }
  1347.         return $list;
  1348.     }
  1350.     /**
  1351.      * Return true if item amount limit is reached
  1352.      *
  1353.      * @param \XLite\Model\OrderItem $item Order item
  1354.      *
  1355.      * @return boolean
  1356.      */
  1357.     protected function isItemLimitReached($item)
  1358.     {
  1359.         $result = false;
  1361.         $object = $item->getObject();
  1363.         if ($object) {
  1364.             $result = $object->getInventoryEnabled() && $object->getPublicAmount() <= $item->getAmount();
  1365.         }
  1367.         return $result;
  1368.     }
  1370.     /**
  1371.      * Get fingerprint by 'itemsCount' key
  1372.      *
  1373.      * @return int
  1374.      */
  1375.     protected function getFingerprintByItemsCount()
  1376.     {
  1377.         return (int) $this->countQuantity();
  1378.     }
  1380.     /**
  1381.      * Get fingerprint by 'shippingTotal' key
  1382.      *
  1383.      * @return float
  1384.      */
  1385.     protected function getFingerprintByShippingTotal()
  1386.     {
  1387.         /** @var \XLite\Logic\Order\Modifier\Shipping $shippingModifier */
  1388.         $shippingModifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  1390.         if (!$shippingModifier) {
  1391.             return 0;
  1392.         }
  1394.         $rate = $shippingModifier->getSelectedRate();
  1396.         return $rate ? (float)$rate->getTotalRate() : 0;
  1397.     }
  1399.     /**
  1400.      * Get fingerprint by 'total' key
  1401.      *
  1402.      * @return float
  1403.      */
  1404.     protected function getFingerprintByTotal()
  1405.     {
  1406.         return (float) $this->getTotal();
  1407.     }
  1409.     /**
  1410.      * Get fingerprint by 'freeShippingNote' key
  1411.      *
  1412.      * @return bool
  1413.      */
  1414.     protected function getFingerPrintByFreeShippingNote()
  1415.     {
  1416.         return $this->showFreeShippingNote();
  1417.     }
  1419.     /**
  1420.      * Get fingerprint by 'shippingMethodId' key
  1421.      *
  1422.      * @return integer
  1423.      */
  1424.     protected function getFingerprintByShippingMethodId()
  1425.     {
  1426.         /** @var \XLite\Logic\Order\Modifier\Shipping $shippingModifier */
  1427.         $shippingModifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  1429.         if (!$shippingModifier) {
  1430.             return 0;
  1431.         }
  1433.         $rate = $shippingModifier->getSelectedRate();
  1435.         return $rate ? $rate->getMethod()->getMethodId() : 0;
  1436.     }
  1438.     /**
  1439.      * Get fingerprint by 'paymentMethodId' key
  1440.      *
  1441.      * @return integer
  1442.      */
  1443.     protected function getFingerprintByPaymentMethodId()
  1444.     {
  1445.         return $this->getPaymentMethod()
  1446.                 ? $this->getPaymentMethod()->getMethodId()
  1447.                 : 0;
  1448.     }
  1450.     /**
  1451.      * Get fingerprint by 'shippingMethodsHash' key
  1452.      *
  1453.      * @return string
  1454.      */
  1455.     protected function getFingerprintByShippingMethodsHash()
  1456.     {
  1457.         /** @var \XLite\Logic\Order\Modifier\Shipping $shippingModifier */
  1458.         $shippingModifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  1459.         $shippingMethodsHash = [];
  1460.         if ($shippingModifier) {
  1461.             $rates = $shippingModifier->getRates();
  1462.             foreach ($rates as $rate) {
  1463.                 $methodId = $rate->getMethod()->getMethodId();
  1464.                 $totalRate = $rate->getTotalRate();
  1465.                 $shippingMethodsHash[] = "$methodId:$totalRate";
  1466.             }
  1467.         }
  1469.         return implode(';', $shippingMethodsHash);
  1470.     }
  1472.     /**
  1473.      * Get fingerprint by 'paymentMethodsHash' key
  1474.      *
  1475.      * @return string
  1476.      */
  1477.     protected function getFingerprintByPaymentMethodsHash()
  1478.     {
  1479.         $paymentMethodsHash = [];
  1480.         foreach ($this->getPaymentMethods() as $method) {
  1481.             $paymentMethodsHash[] = $method->getMethodId();
  1482.         }
  1484.         return implode(';', $paymentMethodsHash);
  1485.     }
  1487.     /**
  1488.      * Get fingerprint by 'shippingAddressId' key
  1489.      *
  1490.      * @return integer
  1491.      */
  1492.     protected function getFingerprintByShippingAddressId()
  1493.     {
  1494.         return $this->getProfile() && $this->getProfile()->getShippingAddress()
  1495.             ? $this->getProfile()->getShippingAddress()->getAddressId()
  1496.             : 0;
  1497.     }
  1499.     /**
  1500.      * Get fingerprint by 'billingAddressId' key
  1501.      *
  1502.      * @return integer
  1503.      */
  1504.     protected function getFingerprintByBillingAddressId()
  1505.     {
  1506.         return $this->getProfile() && $this->getProfile()->getBillingAddress()
  1507.             ? $this->getProfile()->getBillingAddress()->getAddressId()
  1508.             : 0;
  1509.     }
  1511.     /**
  1512.      * @return array
  1513.      */
  1514.     protected function getFingerprintByShippingAddressFields()
  1515.     {
  1516.         if ($this->getProfile() && $this->getProfile()->getShippingAddress()) {
  1517.             return $this->getProfile()->getShippingAddress()->serialize();
  1518.         }
  1520.         return [];
  1521.     }
  1523.     /**
  1524.      * @return array
  1525.      */
  1526.     protected function getFingerprintByBillingAddressFields()
  1527.     {
  1528.         if ($this->getProfile() && $this->getProfile()->getBillingAddress()) {
  1529.             return $this->getProfile()->getBillingAddress()->serialize();
  1530.         }
  1532.         return [];
  1533.     }
  1536.     /**
  1537.      * Get fingerprint by 'sameAddress' key
  1538.      *
  1539.      * @return boolean
  1540.      */
  1541.     protected function getFingerprintBySameAddress()
  1542.     {
  1543.         return $this->getProfile() && $this->getProfile()->isSameAddress();
  1544.     }
  1546.     /**
  1547.      * Get detail
  1548.      *
  1549.      * @param string $name Details cell name
  1550.      *
  1551.      * @return mixed
  1552.      */
  1553.     public function getDetail($name)
  1554.     {
  1555.         $details = $this->getDetails();
  1556.         return \Includes\Utils\ArrayManager::findValue(
  1557.             $details,
  1558.             [$this, 'checkDetailName'],
  1559.             $name
  1560.         );
  1561.     }
  1563.     /**
  1564.      * Get detail value
  1565.      *
  1566.      * @param string $name Details cell name
  1567.      *
  1568.      * @return mixed
  1569.      */
  1570.     public function getDetailValue($name)
  1571.     {
  1572.         $detail = $this->getDetail($name);
  1574.         return $detail ? $detail->getValue() : null;
  1575.     }
  1577.     /**
  1578.      * Set detail cell
  1579.      * To unset detail cell the value should be null
  1580.      *
  1581.      * @param string $name  Cell code
  1582.      * @param mixed  $value Cell value
  1583.      * @param string $label Cell label OPTIONAL
  1584.      *
  1585.      * @return void
  1586.      */
  1587.     public function setDetail($name, $value, $label = null)
  1588.     {
  1589.         $detail = $this->getDetail($name);
  1591.         if ($value === null) {
  1592.             if ($detail) {
  1593.                 $this->getDetails()->removeElement($detail);
  1594.                 \XLite\Core\Database::getEM()->remove($detail);
  1595.             }
  1596.         } else {
  1597.             if (!$detail) {
  1598.                 $detail = new \XLite\Model\OrderDetail();
  1600.                 $detail->setOrder($this);
  1601.                 $this->addDetails($detail);
  1603.                 $detail->setName($name);
  1604.             }
  1606.             $detail->setValue($value);
  1607.             $detail->setLabel($label);
  1608.         }
  1609.     }
  1611.     /**
  1612.      * Get meaning order details
  1613.      *
  1614.      * @return array
  1615.      */
  1616.     public function getMeaningDetails()
  1617.     {
  1618.         $result = [];
  1620.         foreach ($this->getDetails() as $detail) {
  1621.             if ($detail->getLabel()) {
  1622.                 $result[] = $detail;
  1623.             }
  1624.         }
  1626.         return $result;
  1627.     }
  1629.     /**
  1630.      * Called when an order successfully placed by a client
  1631.      *
  1632.      * @throws \Doctrine\ORM\NoResultException
  1633.      * @throws \Doctrine\ORM\NonUniqueResultException
  1634.      */
  1635.     public function processSucceed()
  1636.     {
  1637.         $this->markAsOrder();
  1639.         if ($this->canChangeStatusOnSucceed()) {
  1640.             $this->setShippingStatus(\XLite\Model\Order\Status\Shipping::STATUS_NEW);
  1641.         }
  1644.         $property = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\Property')->findOneBy([
  1645.             'paymentStatus'  => $this->getPaymentStatus(),
  1646.             'shippingStatus' => $this->getShippingStatus(),
  1647.         ]);
  1649.         $incStock = $property ? $property->getIncStock() : null;
  1650.         if ($incStock === false) {
  1651.             $this->processBackorderedItems();
  1652.             $this->decreaseInventory();
  1653.             $this->setStockStatus('reduced');
  1654.         }
  1656.         // Register 'Place order' event in the order history
  1657.         $this->registerPlaceOrder();
  1659.         // Transform attributes
  1660.         $this->transformItemsAttributes();
  1662.         $this->sendOrderCreatedIfNeeded();
  1664.         $this->sendOrderWaitingForApproveIfNeeded();
  1665.     }
  1667.     /**
  1668.      * @return int
  1669.      * @throws \Doctrine\ORM\NoResultException
  1670.      * @throws \Doctrine\ORM\NonUniqueResultException
  1671.      */
  1672.     protected function processBackorderedItems()
  1673.     {
  1674.         $backstockCount = 0;
  1676.         $items = $this->getItems();
  1678.         foreach ($items as $item) {
  1679.             if ($item->isDeleted() || !$this->isInventoryEnabledForItem($item)) {
  1680.                 continue;
  1681.             }
  1682.             \XLite\Core\Database::getEM()->transactional(function (EntityManager $em) use ($item, &$backstockCount) {
  1683.                 $product = $item->getProduct();
  1684.                 $em->lock($item->getProduct(), LockMode::PESSIMISTIC_READ);
  1685.                 $em->refresh($product);
  1687.                 $pa = $this->getProductAmountForItem($item);
  1688.                 $this->reduceProductAmountForItem($item);
  1689.                 $ia = $item->getAmount();
  1690.                 if ($pa < $ia) {
  1691.                     $backstockCount += $ia - $pa;
  1692.                     $item->setBackorderedAmount($ia - $pa);
  1693.                 }
  1694.             });
  1695.         }
  1697.         if ($backstockCount) {
  1698.             \XLite\Core\Mailer::sendBackorderCreatedAdmin($this);
  1699.             $this->setShippingStatus(\XLite\Model\Order\Status\Shipping::STATUS_NEW_BACKORDERED);
  1700.             //Set oldShippingStatus to NBA
  1701.             $this->setShippingStatus(\XLite\Model\Order\Status\Shipping::STATUS_NEW_BACKORDERED);
  1702.             $this->assignBackorderCompetitors();
  1703.         }
  1705.         return $backstockCount;
  1706.     }
  1708.     /**
  1709.      * @throws \Doctrine\ORM\NoResultException
  1710.      * @throws \Doctrine\ORM\NonUniqueResultException
  1711.      */
  1712.     protected function assignBackorderCompetitors()
  1713.     {
  1714.         $repo = Database::getRepo('XLite\Model\Order');
  1715.         $competitors = $this->getBackorderCompetitors();
  1716.         foreach ($this->getItems() as $item) {
  1717.             if (
  1718.                 $item->getBackorderedAmount()
  1719.                 && $competitor = $repo->getBackorderCompetitorByItem($item)
  1720.             ) {
  1721.                 if (!$competitors->contains($competitor)) {
  1722.                     $this->getBackorderCompetitors()->add($competitor);
  1723.                 }
  1724.             }
  1725.         }
  1726.     }
  1728.     /**
  1729.      * @return bool
  1730.      */
  1731.     public function isBackordered()
  1732.     {
  1733.         return $this->getShippingStatusCode() === \XLite\Model\Order\Status\Shipping::STATUS_NEW_BACKORDERED;
  1734.     }
  1736.     /**
  1737.      * @param OrderItem $item
  1738.      *
  1739.      * @return int
  1740.      */
  1741.     protected function getProductAmountForItem(OrderItem $item)
  1742.     {
  1743.         $key = $this->getProductKeyForItem($item);
  1745.         if (!isset($this->backorderProductAmounts[$key])) {
  1746.             $this->backorderProductAmounts[$key] = $this->calculateProductAmountForItem($item);
  1747.         }
  1749.         return $this->backorderProductAmounts[$key];
  1750.     }
  1752.     /**
  1753.      * @param OrderItem $item
  1754.      *
  1755.      * @return int
  1756.      */
  1757.     protected function calculateProductAmountForItem(OrderItem $item)
  1758.     {
  1759.         return $item->getProduct()->getAmount();
  1760.     }
  1762.     /**
  1763.      * @param OrderItem $item
  1764.      *
  1765.      * @return static
  1766.      */
  1767.     protected function reduceProductAmountForItem(OrderItem $item)
  1768.     {
  1769.         $this->backorderProductAmounts[$this->getProductKeyForItem($item)]
  1770.             = max($this->getProductAmountForItem($item) - $item->getAmount(), 0);
  1772.         return $this;
  1773.     }
  1775.     /**
  1776.      * @param OrderItem $item
  1777.      *
  1778.      * @return boolean
  1779.      */
  1780.     protected function isInventoryEnabledForItem(OrderItem $item)
  1781.     {
  1782.         return $item->getProduct()->getInventoryEnabled();
  1783.     }
  1785.     /**
  1786.      * @param OrderItem $item
  1787.      *
  1788.      * @return string
  1789.      */
  1790.     protected function getProductKeyForItem(OrderItem $item)
  1791.     {
  1792.         return $item->getProduct()->getId();
  1793.     }
  1795.     protected function registerPlaceOrder()
  1796.     {
  1797.         \XLite\Core\OrderHistory::getInstance()->registerPlaceOrder($this->getOrderId());
  1798.     }
  1800.     /**
  1801.      * Send order created notification if needed
  1802.      */
  1803.     public function sendOrderCreatedIfNeeded()
  1804.     {
  1805.         if (
  1806.             $this->getPaymentStatus()
  1807.             && in_array(
  1808.                 $this->getPaymentStatus()->getCode(),
  1809.                 $this->getValidStatusesForCreateNotification(),
  1810.                 true
  1811.             )
  1812.         ) {
  1813.             \XLite\Core\Mailer::sendOrderCreated($this);
  1814.         }
  1815.     }
  1817.     /**
  1818.      * Send order awaiting approval notification if needed
  1819.      */
  1820.     public function sendOrderWaitingForApproveIfNeeded()
  1821.     {
  1822.         if (
  1823.             $this->getShippingStatus()
  1824.             && $this->getShippingStatus()->getCode() === \XLite\Model\Order\Status\Shipping::STATUS_WAITING_FOR_APPROVE
  1825.         ) {
  1826.             \XLite\Core\Mailer::sendOrderWaitingForApprove($this);
  1827.         }
  1828.     }
  1830.     /**
  1831.      * Valid not paid statuses
  1832.      *
  1833.      * @return array
  1834.      */
  1835.     public function getValidStatusesForCreateNotification()
  1836.     {
  1837.         return [
  1838.             \XLite\Model\Order\Status\Payment::STATUS_QUEUED,
  1839.             \XLite\Model\Order\Status\Payment::STATUS_AUTHORIZED,
  1840.         ];
  1841.     }
  1843.     /**
  1844.      * Mark cart as order
  1845.      *
  1846.      * @return void
  1847.      */
  1848.     public function markAsOrder()
  1849.     {
  1850.     }
  1852.     /**
  1853.      * Mark order as cart
  1854.      *
  1855.      * @return void
  1856.      */
  1857.     public function markAsCart()
  1858.     {
  1859.         $this->getRepository()->markAsCart($this->getOrderId());
  1860.     }
  1862.     /**
  1863.      * Refresh order items
  1864.      * TODO - rework after tax subsystem rework
  1865.      *
  1866.      * @return void
  1867.      */
  1868.     public function refreshItems()
  1869.     {
  1870.     }
  1872.     /**
  1873.      * Return removing status
  1874.      *
  1875.      * @return boolean
  1876.      */
  1877.     public function isRemoving()
  1878.     {
  1879.         return $this->isRemoving;
  1880.     }
  1882.     /**
  1883.      * Constructor
  1884.      *
  1885.      * @param array $data Entity properties OPTIONAL
  1886.      */
  1887.     public function __construct(array $data = [])
  1888.     {
  1889.         $this->details              = new ArrayCollection();
  1890.         $this->items                = new ArrayCollection();
  1891.         $this->surcharges           = new ArrayCollection();
  1892.         $this->payment_transactions = new ArrayCollection();
  1893.         $this->events               = new ArrayCollection();
  1894.         $this->trackingNumbers      = new ArrayCollection();
  1895.         $this->backorderCompetitors = new ArrayCollection();
  1897.         parent::__construct($data);
  1898.     }
  1900.     /**
  1901.      * Return list of available payment methods
  1902.      *
  1903.      * @return array
  1904.      */
  1905.     public function getPaymentMethods()
  1906.     {
  1907.         if (0 >= $this->getOpenTotal()) {
  1908.             return [];
  1909.         }
  1911.         $list = \XLite\Core\Database::getRepo('XLite\Model\Payment\Method')
  1912.             ->findAllActive();
  1914.         foreach ($list as $i => $method) {
  1915.             if (!$method->isEnabled() || !$method->getProcessor()->isApplicable($this, $method)) {
  1916.                 unset($list[$i]);
  1917.             }
  1918.         }
  1920.         if (\XLite\Core\Auth::getInstance()->isOperatingAsUserMode()) {
  1921.             $fakeMethods = \XLite\Core\Auth::getInstance()->getOperateAsUserPaymentMethods();
  1923.             $filteredFakeMethods = array_filter(
  1924.                 $fakeMethods,
  1925.                 static function ($fakeMethod) use ($list) {
  1926.                     $fakeServiceName = $fakeMethod->getServiceName();
  1928.                     // Check if $list already contains fake method
  1929.                     return !array_reduce($list, static function ($carry, $method) use ($fakeServiceName) {
  1930.                         return $carry ?: $method->getServiceName() === $fakeServiceName;
  1931.                     }, false);
  1932.                 }
  1933.             );
  1935.             $list = array_merge(
  1936.                 $list,
  1937.                 $filteredFakeMethods
  1938.             );
  1939.         }
  1941.         return $list;
  1942.     }
  1944.     /**
  1945.      * Renew payment method
  1946.      *
  1947.      * @return void
  1948.      */
  1949.     public function renewPaymentMethod()
  1950.     {
  1951.         if ($this->isPaymentMethodRequired()) {
  1952.             $method = $this->getPaymentMethod();
  1954.             if ($this->isPaymentMethodIsApplicable($method)) {
  1955.                 $this->setPaymentMethod($method);
  1956.             } else {
  1957.                 $first = $this->getFirstPaymentMethod();
  1958.                 if ($first) {
  1959.                     if ($this->getProfile()) {
  1960.                         $this->getProfile()->setLastPaymentId($first->getMethodId());
  1961.                     }
  1963.                     $this->setPaymentMethod($first);
  1964.                 } else {
  1965.                     $this->unsetPaymentMethod();
  1966.                 }
  1967.             }
  1968.         } else {
  1969.             $this->unsetPaymentMethod();
  1970.         }
  1971.     }
  1973.     /**
  1974.      * Returns true if order is allowed to change status on succeed
  1975.      *
  1976.      * @return boolean
  1977.      */
  1978.     protected function canChangeStatusOnSucceed()
  1979.     {
  1980.         return $this->getShippingStatus() === null;
  1981.     }
  1983.     /**
  1984.      * Return true if payment method is required for the order
  1985.      *
  1986.      * @return boolean
  1987.      */
  1988.     protected function isPaymentMethodRequired()
  1989.     {
  1990.         return 0 < $this->getOpenTotal()
  1991.             && ($this instanceof \XLite\Model\Cart || $this->getOrderNumber() === null);
  1992.     }
  1994.     /**
  1995.      * Check if given payment method can be applied to the order
  1996.      *
  1997.      * @param  \XLite\Model\Payment\Method  $method
  1998.      * @return boolean
  1999.      */
  2000.     protected function isPaymentMethodIsApplicable($method)
  2001.     {
  2002.         return $method
  2003.             && $method->getProcessor()
  2004.             && $method->getProcessor()->isApplicable($this, $method);
  2005.     }
  2007.     /**
  2008.      * Get payment method
  2009.      *
  2010.      * @return \XLite\Model\Payment\Method|null
  2011.      */
  2012.     public function getPaymentMethod()
  2013.     {
  2014.         $transaction = $this->getFirstOpenPaymentTransaction();
  2015.         if (!$transaction) {
  2016.             $transaction = $this->hasUnpaidTotal() || count($this->getPaymentTransactions()) === 0
  2017.                 ? $this->assignLastPaymentMethod()
  2018.                 : $this->getPaymentTransactions()->last();
  2019.         }
  2021.         return $transaction ? $transaction->getPaymentMethod() : null;
  2022.     }
  2024.     /**
  2025.      * Check item key equal
  2026.      *
  2027.      * @param \XLite\Model\OrderItem $item Item
  2028.      * @param string                 $key  Key
  2029.      *
  2030.      * @return boolean
  2031.      */
  2032.     public function checkItemKeyEqual(\XLite\Model\OrderItem $item, $key)
  2033.     {
  2034.         return $item->getKey() == $key;
  2035.     }
  2037.     /**
  2038.      * Check item id equal
  2039.      *
  2040.      * @param \XLite\Model\OrderItem $item   Item
  2041.      * @param integer                $itemId Item id
  2042.      *
  2043.      * @return boolean
  2044.      */
  2045.     public function checkItemIdEqual(\XLite\Model\OrderItem $item, $itemId)
  2046.     {
  2047.         return $item->getItemId() == $itemId;
  2048.     }
  2050.     /**
  2051.      * Check order detail name
  2052.      *
  2053.      * @param \XLite\Model\OrderDetail $detail Detail
  2054.      * @param string                   $name   Name
  2055.      *
  2056.      * @return boolean
  2057.      */
  2058.     public function checkDetailName(\XLite\Model\OrderDetail $detail, $name)
  2059.     {
  2060.         return $detail->getName() === $name;
  2061.     }
  2063.     /**
  2064.      * Check payment transaction status
  2065.      *
  2066.      * @param \XLite\Model\Payment\Transaction $transaction Transaction
  2067.      * @param mixed                            $status      Status
  2068.      *
  2069.      * @return boolean
  2070.      */
  2071.     public function checkPaymentTransactionStatusEqual(\XLite\Model\Payment\Transaction $transaction, $status)
  2072.     {
  2073.         return is_array($status)
  2074.             ? in_array($transaction->getStatus(), $status, true)
  2075.             : $transaction->getStatus() === $status;
  2076.     }
  2078.     /**
  2079.      * Check payment transaction - open or not
  2080.      *
  2081.      * @param \XLite\Model\Payment\Transaction $transaction Payment transaction
  2082.      *
  2083.      * @return boolean
  2084.      */
  2085.     public function checkPaymentTransactionOpen(\XLite\Model\Payment\Transaction $transaction)
  2086.     {
  2087.         return $transaction->isOpen() || $transaction->isInProgress();
  2088.     }
  2090.     /**
  2091.      * Check - is item product id equal specified product id
  2092.      *
  2093.      * @param \XLite\Model\OrderItem $item      Item
  2094.      * @param integer                $productId Product id
  2095.      *
  2096.      * @return boolean
  2097.      */
  2098.     public function isItemProductIdEqual(\XLite\Model\OrderItem $item, $productId)
  2099.     {
  2100.         return $item->getProductId() == $productId;
  2101.     }
  2103.     /**
  2104.      * Check last payment method
  2105.      *
  2106.      * @param \XLite\Model\Payment\Method $pmethod       Payment method
  2107.      * @param integer                     $lastPaymentId Last selected payment method id
  2108.      *
  2109.      * @return boolean
  2110.      */
  2111.     public function checkLastPaymentMethod(\XLite\Model\Payment\Method $pmethod, $lastPaymentId)
  2112.     {
  2113.         $result = $pmethod->getMethodId() == $lastPaymentId;
  2114.         if ($result) {
  2115.             $this->setPaymentMethod($pmethod);
  2117.             \XLite\Core\Database::getEM()->flush();
  2118.         }
  2120.         return $result;
  2121.     }
  2123.     // {{{ Payment method and transactions
  2125.     /**
  2126.      * Set payment method
  2127.      *
  2128.      * @param \XLite\Model\Payment\Method|null $paymentMethod Payment method
  2129.      * @param float                            $value         Payment transaction value OPTIONAL
  2130.      *
  2131.      * @return void
  2132.      */
  2133.     public function setPaymentMethod($paymentMethod, $value = null)
  2134.     {
  2135.         if ($paymentMethod && !($paymentMethod instanceof \XLite\Model\Payment\Method)) {
  2136.             $paymentMethod = null;
  2137.         }
  2139.         $sameMethod = false;
  2141.         if ($paymentMethod === null || $this->getFirstOpenPaymentTransaction()) {
  2142.             $transaction = $this->getFirstOpenPaymentTransaction();
  2143.             if ($transaction) {
  2144.                 if ($paymentMethod === null) {
  2145.                     $this->unsetPaymentMethod();
  2146.                 } elseif ($transaction->isSameMethod($paymentMethod)) {
  2147.                     $transaction->updateValue($this);
  2148.                     $sameMethod = true;
  2149.                 }
  2150.             }
  2151.         }
  2153.         if ($paymentMethod === null) {
  2154.             $this->setPaymentMethodName('');
  2155.         } elseif (!$sameMethod) {
  2156.             $this->unsetPaymentMethod();
  2157.             $this->addPaymentTransaction($paymentMethod, $value);
  2158.             $this->setPaymentMethodName($paymentMethod->getName());
  2159.         }
  2160.     }
  2162.     /**
  2163.      * Unset payment method
  2164.      *
  2165.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  2166.      *
  2167.      * @return void
  2168.      */
  2169.     public function unsetPaymentMethod()
  2170.     {
  2171.         $transaction = $this->getFirstOpenPaymentTransaction();
  2173.         $this->setPaymentMethodName('');
  2175.         if ($transaction) {
  2176.             $this->payment_transactions->removeElement($transaction);
  2177.             \XLite\Core\Database::getEM()->remove($transaction);
  2178.         }
  2179.     }
  2181.     /**
  2182.      * Get active payment transactions
  2183.      *
  2184.      * @return array
  2185.      */
  2186.     public function getActivePaymentTransactions()
  2187.     {
  2188.         $result = [];
  2189.         foreach ($this->getPaymentTransactions() as $t) {
  2190.             if ($t->isCompleted() || $t->isPending()) {
  2191.                 $result[] = $t;
  2192.             }
  2193.         }
  2195.         return $result;
  2196.     }
  2198.     /**
  2199.      * Get visible payment methods
  2200.      *
  2201.      * @return array
  2202.      */
  2203.     public function getVisiblePaymentMethods()
  2204.     {
  2205.         $result = [];
  2207.         foreach ($this->getActivePaymentTransactions() as $t) {
  2208.             if ($t->getPaymentMethod()) {
  2209.                 $result[] = $t->getPaymentMethod();
  2210.             }
  2211.         }
  2213.         if (count($result) === 0 && 0 < count($this->getPaymentTransactions())) {
  2214.             $method = $this->getPaymentTransactions()->last()->getPaymentMethod();
  2215.             if ($method) {
  2216.                 $result[] = $method;
  2217.             }
  2218.         }
  2220.         return $result;
  2221.     }
  2223.     /**
  2224.      * Get first open (not payed) payment transaction
  2225.      *
  2226.      * @return \XLite\Model\Payment\Transaction|null
  2227.      */
  2228.     public function getFirstOpenPaymentTransaction()
  2229.     {
  2230.         $transactions = $this->getPaymentTransactions();
  2232.         return \Includes\Utils\ArrayManager::findValue(
  2233.             $transactions,
  2234.             [$this, 'checkPaymentTransactionOpen']
  2235.         );
  2236.     }
  2238.     /**
  2239.      * Get open (not-payed) total
  2240.      *
  2241.      * @return float
  2242.      */
  2243.     public function getOpenTotal()
  2244.     {
  2245.         $total = $this->getCurrency()->roundValue($this->getTotal());
  2246.         $totalAsSurcharges = $this->getCurrency()->roundValue($this->getSurchargesTotal());
  2248.         $totalsPaid = $this->getPaidTotals();
  2250.         return max(
  2251.             $total - $totalsPaid['total'],
  2252.             $totalAsSurcharges - $totalsPaid['totalAsSurcharges']
  2253.         );
  2254.     }
  2256.     public function getPaidTotals()
  2257.     {
  2258.         $total = $totalAsSurcharges = 0;
  2260.         foreach ($this->getPaymentTransactions() as $t) {
  2261.             $total += $this->getCurrency()->roundValue($t->getChargeValueModifier());
  2262.             $totalAsSurcharges += $this->getCurrency()->roundValue($t->getChargeValueModifier());
  2263.         }
  2265.         return [
  2266.             'total'             => $total,
  2267.             'totalAsSurcharges' => $totalAsSurcharges,
  2268.         ];
  2269.     }
  2271.     /**
  2272.      * Get paid total
  2273.      *
  2274.      * @return float
  2275.      */
  2276.     public function getPaidTotal()
  2277.     {
  2278.         $totals = $this->getPaidTotals();
  2280.         return max(
  2281.             $totals['total'],
  2282.             $totals['totalAsSurcharges']
  2283.         );
  2284.     }
  2286.     /**
  2287.      * Check - order is open (has initialized transactions and has open total) or not
  2288.      *
  2289.      * @return boolean
  2290.      */
  2291.     public function isOpen()
  2292.     {
  2293.         return $this->getFirstOpenPaymentTransaction() && $this->hasUnpaidTotal();
  2294.     }
  2296.     /**
  2297.      * Has unpaid total?
  2298.      *
  2299.      * @return boolean
  2300.      */
  2301.     public function hasUnpaidTotal()
  2302.     {
  2303.         return $this->getCurrency()->getMinimumValue() <= $this->getCurrency()->roundValue(abs($this->getOpenTotal()));
  2304.     }
  2306.     /**
  2307.      * Get totally payed total
  2308.      *
  2309.      * @return float
  2310.      */
  2311.     public function getPayedTotal()
  2312.     {
  2313.         $total = $this->getCurrency()->roundValue($this->getTotal());
  2315.         foreach ($this->getPaymentTransactions() as $t) {
  2316.             if ($t->isCompleted() && ($t->isAuthorized() || $t->isCaptured())) {
  2317.                 $total -= $this->getCurrency()->roundValue($t->getChargeValueModifier());
  2318.             }
  2319.         }
  2321.         $sums = $this->getRawPaymentTransactionSums();
  2322.         $total += $sums['refunded'];
  2324.         return $total;
  2325.     }
  2327.     /**
  2328.      * Check - order is payed or not
  2329.      * Payed - order has not open total and all payment transactions are failed or completed
  2330.      *
  2331.      * @return boolean
  2332.      */
  2333.     public function isPayed()
  2334.     {
  2335.         return 0 >= $this->getPayedTotal();
  2336.     }
  2338.     /**
  2339.      * Check - order has in-progress payments or not
  2340.      *
  2341.      * @return boolean
  2342.      */
  2343.     public function hasInprogressPayments()
  2344.     {
  2345.         $result = false;
  2347.         foreach ($this->getPaymentTransactions() as $t) {
  2348.             if ($t->isInProgress()) {
  2349.                 $result = true;
  2350.                 break;
  2351.             }
  2352.         }
  2354.         return $result;
  2355.     }
  2357.     /**
  2358.      * Assign last used payment method
  2359.      *
  2360.      * @return \XLite\Model\Payment\Transaction|void
  2361.      */
  2362.     protected function assignLastPaymentMethod()
  2363.     {
  2364.         $found = null;
  2366.         if ($this->isPaymentMethodRequired() && $this->getProfile() && $this->getProfile()->getLastPaymentId()) {
  2367.             $paymentMethods = $this->getPaymentMethods();
  2368.             $found = \Includes\Utils\ArrayManager::findValue(
  2369.                 $paymentMethods,
  2370.                 [$this, 'checkLastPaymentMethod'],
  2371.                 $this->getProfile()->getLastPaymentId()
  2372.             );
  2373.         }
  2375.         return $found ? $this->getFirstOpenPaymentTransaction() : null;
  2376.     }
  2378.     /**
  2379.      * Get first applicable payment method
  2380.      *
  2381.      * @return \XLite\Model\Payment\Method
  2382.      */
  2383.     protected function getFirstPaymentMethod()
  2384.     {
  2385.         $list = $this->getPaymentMethods();
  2387.         return $list ? array_shift($list) : null;
  2388.     }
  2390.     /**
  2391.      * Add payment transaction
  2392.      * FIXME: move logic into \XLite\Model\Payment\Transaction
  2393.      *
  2394.      * @param \XLite\Model\Payment\Method $method Payment method
  2395.      * @param float                       $value  Value OPTIONAL
  2396.      *
  2397.      * @throws \Doctrine\ORM\ORMInvalidArgumentException
  2398.      *
  2399.      * @return void
  2400.      */
  2401.     protected function addPaymentTransaction(\XLite\Model\Payment\Method $method, $value = null)
  2402.     {
  2403.         if ($value === null || 0 >= $value) {
  2404.             $value = $this->getOpenTotal();
  2405.         } else {
  2406.             $value = min($value, $this->getOpenTotal());
  2407.         }
  2409.         // Do not add 0 or <0 transactions. This is for a "Payment not required" case.
  2410.         if ($value > 0) {
  2411.             $transaction = new \XLite\Model\Payment\Transaction();
  2413.             $this->addPaymentTransactions($transaction);
  2414.             $transaction->setOrder($this);
  2416.             $transaction->setPaymentMethod($method);
  2418.             \XLite\Core\Database::getEM()->persist($method);
  2420.             $transaction->setCurrency($this->getCurrency());
  2422.             $transaction->setStatus($transaction::STATUS_INITIALIZED);
  2423.             $transaction->setValue($value);
  2424.             $transaction->setType($method->getProcessor()->getInitialTransactionType($method));
  2426.             if ($method->getProcessor()->isTestMode($method)) {
  2427.                 $transaction->setDataCell(
  2428.                     'test_mode',
  2429.                     true,
  2430.                     'Test mode'
  2431.                 );
  2432.             }
  2434.             \XLite\Core\Database::getEM()->persist($transaction);
  2435.         }
  2436.     }
  2438.     // }}}
  2440.     // {{{ Shipping
  2442.     /**
  2443.      * Returns last shipping method id
  2444.      *
  2445.      * @return integer|null
  2446.      */
  2447.     public function getLastShippingId()
  2448.     {
  2449.         /** @var \XLite\Model\Profile $profile */
  2450.         $profile = $this->getProfile();
  2452.         return $profile ? $profile->getLastShippingId() : null;
  2453.     }
  2455.     /**
  2456.      * Sets last shipping method id used
  2457.      *
  2458.      * @param integer $value Method id
  2459.      *
  2460.      * @return void
  2461.      */
  2462.     public function setLastShippingId($value)
  2463.     {
  2464.         /** @var \XLite\Model\Profile $profile */
  2465.         $profile = $this->getProfile();
  2467.         if ($profile !== null) {
  2468.             $profile->setLastShippingId($value);
  2469.         }
  2470.     }
  2472.     /**
  2473.      * Renew shipping method
  2474.      *
  2475.      * @return void
  2476.      */
  2477.     public function renewShippingMethod()
  2478.     {
  2479.         if (!\XLite\Model\Shipping::getInstance()->shouldAllowLongCalculations()) {
  2480.             return;
  2481.         }
  2483.         $this->updateEmptyShippingID();
  2485.         /** @var \XLite\Logic\Order\Modifier\Shipping $modifier */
  2486.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  2487.         if ($modifier && $modifier->getSelectedRate() === null) {
  2488.             $method = $this->getFirstShippingMethod();
  2490.             if ($method) {
  2491.                 $methodId = $method->getMethodId();
  2493.                 $this->setLastShippingId($methodId);
  2494.                 $this->setShippingId($methodId);
  2495.             } else {
  2496.                 $this->setShippingId(0);
  2497.             }
  2498.         }
  2499.     }
  2501.     /**
  2502.      * Get the link for the detailed tracking information
  2503.      *
  2504.      * @return boolean|\XLite\Model\Shipping\Processor\AProcessor False if the shipping is not set or
  2505.      *                                                            shipping processor is absent
  2506.      */
  2507.     public function getShippingProcessor()
  2508.     {
  2509.         if ($this->shippingProcessor === null) {
  2510.             $shipping = \XLite\Core\Database::getRepo('XLite\Model\Shipping\Method')->find($this->getShippingId());
  2511.             $this->shippingProcessor = $shipping && $shipping->getProcessorObject()
  2512.                 ? $shipping->getProcessorObject()
  2513.                 : false;
  2514.         }
  2516.         return $this->shippingProcessor;
  2517.     }
  2519.     /**
  2520.      * Defines whether the form must be used for tracking information.
  2521.      * The 'getTrackingInformationURL' result will be used as tracking link instead
  2522.      *
  2523.      * @param string $trackingNumber Tracking number value
  2524.      *
  2525.      * @return boolean
  2526.      */
  2527.     public function isTrackingInformationForm($trackingNumber)
  2528.     {
  2529.         return $this->getShippingProcessor()
  2530.             ? $this->getShippingProcessor()->isTrackingInformationForm($trackingNumber)
  2531.             : null;
  2532.     }
  2534.     /**
  2535.      * Get the link for the detailed tracking information
  2536.      *
  2537.      * @param string $trackingNumber Tracking number value
  2538.      *
  2539.      * @return null|string
  2540.      */
  2541.     public function getTrackingInformationURL($trackingNumber)
  2542.     {
  2543.         return $this->getShippingProcessor()
  2544.             ? $this->getShippingProcessor()->getTrackingInformationURL($trackingNumber)
  2545.             : null;
  2546.     }
  2548.     /**
  2549.      * Get the form parameters for the detailed tracking information
  2550.      *
  2551.      * @param string $trackingNumber Tracking number value
  2552.      *
  2553.      * @return null|array
  2554.      */
  2555.     public function getTrackingInformationParams($trackingNumber)
  2556.     {
  2557.         return $this->getShippingProcessor()
  2558.             ? $this->getShippingProcessor()->getTrackingInformationParams($trackingNumber)
  2559.             : null;
  2560.     }
  2562.     /**
  2563.      * Get the form method for the detailed tracking information
  2564.      *
  2565.      * @param string $trackingNumber Tracking number value
  2566.      *
  2567.      * @return null|string
  2568.      */
  2569.     public function getTrackingInformationMethod($trackingNumber)
  2570.     {
  2571.         return $this->getShippingProcessor()
  2572.             ? $this->getShippingProcessor()->getTrackingInformationMethod($trackingNumber)
  2573.             : null;
  2574.     }
  2576.     /**
  2577.      * Get first shipping method
  2578.      *
  2579.      * @return \XLite\Model\Shipping\Method
  2580.      */
  2581.     protected function getFirstShippingMethod()
  2582.     {
  2583.         $method = null;
  2585.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  2586.         if ($modifier) {
  2587.             $rates = $modifier->getRates();
  2588.             $rate = array_shift($rates);
  2589.             if ($rate) {
  2590.                 $method = $rate->getMethod();
  2591.             }
  2592.         }
  2594.         return $method;
  2595.     }
  2597.     // }}}
  2599.     // {{{ Mail notification
  2601.     /**
  2602.      * Set value of isNotificationSent flag and return old value
  2603.      *
  2604.      * @param boolean $value New value
  2605.      *
  2606.      * @return boolean
  2607.      */
  2608.     public function setIsNotificationSent($value)
  2609.     {
  2610.         $oldValue = $this->isNotificationSent;
  2611.         $this->isNotificationSent = $value;
  2613.         return $oldValue;
  2614.     }
  2616.     /**
  2617.      * Get value of isNotificationSent flag
  2618.      *
  2619.      * @return boolean
  2620.      */
  2621.     public function isNotificationSent()
  2622.     {
  2623.         return $this->isNotificationSent;
  2624.     }
  2626.     /**
  2627.      * Set value of isNotificationsAllowedFlag flag and return old value
  2628.      *
  2629.      * @param boolean $value New value
  2630.      *
  2631.      * @return boolean
  2632.      */
  2633.     public function setIsNotificationsAllowedFlag($value)
  2634.     {
  2635.         $oldValue = $this->isNotificationsAllowedFlag;
  2636.         $this->isNotificationsAllowedFlag = (bool)$value;
  2638.         return $oldValue;
  2639.     }
  2641.     /**
  2642.      * Set value of ignoreCustomerNotifications flag and return old value
  2643.      *
  2644.      * @param boolean $value New value
  2645.      *
  2646.      * @return boolean
  2647.      */
  2648.     public function setIgnoreCustomerNotifications($value)
  2649.     {
  2650.         $oldValue = $this->ignoreCustomerNotifications;
  2651.         $this->ignoreCustomerNotifications = (bool)$value;
  2653.         return $oldValue;
  2654.     }
  2656.     /**
  2657.      * Get value of isNotificationsAllowedFlag flag
  2658.      *
  2659.      * @return boolean
  2660.      */
  2661.     protected function isNotificationsAllowed()
  2662.     {
  2663.         return $this->isNotificationsAllowedFlag;
  2664.     }
  2666.     /**
  2667.      * Get value of ignoreCustomerNotifications flag
  2668.      *
  2669.      * @return boolean
  2670.      */
  2671.     protected function isIgnoreCustomerNotifications()
  2672.     {
  2673.         return $this->ignoreCustomerNotifications;
  2674.     }
  2676.     // }}}
  2678.     // {{{ Calculation
  2680.     /**
  2681.      * Get modifiers
  2682.      *
  2683.      * @return \XLite\DataSet\Collection\OrderModifier
  2684.      */
  2685.     public function getModifiers()
  2686.     {
  2687.         if ($this->modifiers === null) {
  2688.             $this->modifiers = \XLite\Core\Database::getRepo('XLite\Model\Order\Modifier')->findActive();
  2690.             // Initialize
  2691.             foreach ($this->modifiers as $modifier) {
  2692.                 $modifier->initialize($this, $this->modifiers);
  2693.             }
  2695.             // Preprocess modifiers
  2696.             foreach ($this->modifiers as $modifier) {
  2697.                 $modifier->preprocess();
  2698.             }
  2699.         }
  2701.         return $this->modifiers;
  2702.     }
  2704.     /**
  2705.      * Get modifier
  2706.      *
  2707.      * @param string $type Modifier type
  2708.      * @param string $code Modifier code
  2709.      *
  2710.      * @return \XLite\Model\Order\Modifier
  2711.      */
  2712.     public function getModifier($type, $code)
  2713.     {
  2714.         $result = null;
  2716.         foreach ($this->getModifiers() as $modifier) {
  2717.             if ($modifier->getType() === $type && $modifier->getCode() === $code) {
  2718.                 $result = $modifier;
  2719.                 break;
  2720.             }
  2721.         }
  2723.         return $result;
  2724.     }
  2726.     /**
  2727.      * Check - modifier is exists or not (by type)
  2728.      *
  2729.      * @param string $type Type
  2730.      *
  2731.      * @return boolean
  2732.      */
  2733.     public function isModifierByType($type)
  2734.     {
  2735.         $result = false;
  2737.         foreach ($this->getModifiers() as $modifier) {
  2738.             if ($modifier->getType() === $type) {
  2739.                 $result = true;
  2740.                 break;
  2741.             }
  2742.         }
  2744.         return $result;
  2745.     }
  2747.     /**
  2748.      * Get modifiers by type
  2749.      *
  2750.      * @param string $type Modifier type
  2751.      *
  2752.      * @return array
  2753.      */
  2754.     public function getModifiersByType($type)
  2755.     {
  2756.         $list = [];
  2758.         foreach ($this->getModifiers() as $modifier) {
  2759.             if ($modifier->getType() === $type) {
  2760.                 $list[] = $modifier;
  2761.             }
  2762.         }
  2764.         return $list;
  2765.     }
  2767.     /**
  2768.      * Get items exclude surcharges info
  2769.      *
  2770.      * @return array
  2771.      */
  2772.     public function getItemsExcludeSurcharges()
  2773.     {
  2774.         $list = [];
  2776.         foreach ($this->getItems() as $item) {
  2777.             foreach ($item->getExcludeSurcharges() as $surcharge) {
  2778.                 if (!isset($list[$surcharge->getKey()])) {
  2779.                     $list[$surcharge->getKey()] = $surcharge->getName();
  2780.                 }
  2781.             }
  2782.         }
  2784.         return $list;
  2785.     }
  2787.     /**
  2788.      * Get items included surcharges totals
  2789.      *
  2790.      * @param boolean $forCartItems Flag: true - return values for cart items only, false - for cart totals and items
  2791.      *
  2792.      * @return array
  2793.      */
  2794.     public function getItemsIncludeSurchargesTotals($forCartItems = false)
  2795.     {
  2796.         $list = [];
  2798.         if ($forCartItems) {
  2799.             // Add surcharges for cart items
  2800.             foreach ($this->getItems() as $item) {
  2801.                 foreach ($item->getIncludeSurcharges() as $surcharge) {
  2802.                     if (!isset($list[$surcharge->getKey()])) {
  2803.                         $list[$surcharge->getKey()] = [
  2804.                             'surcharge' => $surcharge,
  2805.                             'cost'      => 0,
  2806.                         ];
  2807.                     }
  2809.                     $list[$surcharge->getKey()]['cost'] += $surcharge->getValue();
  2810.                 }
  2811.             }
  2812.         } else {
  2813.             // Get global cart surcharges
  2814.             foreach ($this->getIncludeSurcharges() as $surcharge) {
  2815.                 if (!isset($list[$surcharge->getKey()])) {
  2816.                     $list[$surcharge->getKey()] = [
  2817.                         'surcharge' => $surcharge,
  2818.                         'cost'      => 0,
  2819.                     ];
  2820.                 }
  2822.                 $list[$surcharge->getKey()]['cost'] += $surcharge->getValue();
  2823.             }
  2824.         }
  2826.         return $list;
  2827.     }
  2829.     /**
  2830.      * Common method to update cart/order
  2831.      *
  2832.      * @return void
  2833.      */
  2834.     public function updateOrder()
  2835.     {
  2836.         $this->normalizeItems();
  2838.         $this->reinitializeCurrency();
  2840.         // If shipping method is not selected or shipping conditions is changed (remove order items or changed address)
  2841.         $this->renewShippingMethod();
  2843.         $this->calculateInitialValues();
  2845.         $this->calculate();
  2847.         $this->renewPaymentMethod();
  2848.     }
  2850.     /**
  2851.      * Calculate order
  2852.      *
  2853.      * @return void
  2854.      */
  2855.     public function calculate()
  2856.     {
  2857.         $oldSurcharges = $this->resetSurcharges();
  2859.         $this->reinitializeCurrency();
  2861.         $this->calculateInitialValues();
  2863.         foreach ($this->getModifiers() as $modifier) {
  2864.             if ($modifier->canApply()) {
  2865.                 $modifier->calculate();
  2866.             }
  2867.         }
  2869.         $this->mergeSurcharges($oldSurcharges);
  2871.         $this->finalizeItemsCalculation();
  2873.         $this->setTotal(max($this->getSurchargesTotal(), 0));
  2874.     }
  2876.     /**
  2877.      * Recalculate edited order
  2878.      *
  2879.      * @return void
  2880.      */
  2881.     public function recalculate()
  2882.     {
  2883.         $this->reinitializeCurrency();
  2885.         $this->finalizeItemsCalculation();
  2887.         $this->setTotal($this->getSurchargesTotal());
  2888.     }
  2890.     /**
  2891.      * Renew order
  2892.      *
  2893.      * @return void
  2894.      */
  2895.     public function renew()
  2896.     {
  2897.         foreach ($this->getItems() as $item) {
  2898.             if (!$item->renew()) {
  2899.                 $this->getItems()->removeElement($item);
  2900.                 \XLite\Core\Database::getRepo('XLite\Model\OrderItem')->delete($item);
  2901.             }
  2902.         }
  2904.         $this->calculate();
  2905.     }
  2907.     /**
  2908.      * Soft renew
  2909.      *
  2910.      * @return void
  2911.      */
  2912.     public function renewSoft()
  2913.     {
  2914.         $this->reinitializeCurrency();
  2915.     }
  2917.     /**
  2918.      * Reinitialize currency
  2919.      *
  2920.      * @return void
  2921.      */
  2922.     protected function reinitializeCurrency()
  2923.     {
  2924.         $new = $this->defineCurrency();
  2925.         $old = $this->getCurrency();
  2927.         if (empty($old) || (!empty($new) && $old->getCode() !== $new->getCode())) {
  2928.             $this->setCurrency($new);
  2929.         }
  2930.     }
  2932.     /**
  2933.      * Define order currency
  2934.      *
  2935.      * @return \XLite\Model\Currency
  2936.      */
  2937.     protected function defineCurrency()
  2938.     {
  2939.         return \XLite::getInstance()->getCurrency();
  2940.     }
  2942.     /**
  2943.      * Reset surcharges list
  2944.      *
  2945.      * @return array
  2946.      */
  2947.     public function resetSurcharges()
  2948.     {
  2949.         $result = [
  2950.             'items' => [],
  2951.         ];
  2953.         $result['items'] = $this->resetItemsSurcharges($this->getItems()->toArray());
  2954.         $result['surcharges'] = parent::resetSurcharges();
  2956.         return $result;
  2957.     }
  2959.     /**
  2960.      * Reset order items surcharge
  2961.      *
  2962.      * @param \XLite\Model\OrderItem[] $items Order items
  2963.      *
  2964.      * @return array
  2965.      */
  2966.     protected function resetSelfSurcharges($items)
  2967.     {
  2968.         $result = [];
  2970.         foreach ($items as $item) {
  2971.             $result[$item->getItemId()] = $item->resetSurcharges();
  2972.         }
  2974.         return $result;
  2975.     }
  2977.     /**
  2978.      * Reset order items surcharge
  2979.      *
  2980.      * @param \XLite\Model\OrderItem[] $items Order items
  2981.      *
  2982.      * @return array
  2983.      */
  2984.     protected function resetItemsSurcharges($items)
  2985.     {
  2986.         $result = [];
  2988.         foreach ($items as $item) {
  2989.             $result[$item->getItemId() ?: spl_object_hash($item)] = $item->resetSurcharges();
  2990.         }
  2992.         return $result;
  2993.     }
  2995.     /**
  2996.      * Merge surcharges
  2997.      *
  2998.      * @param array $oldSurcharges Old surcharges
  2999.      *
  3000.      * @return void
  3001.      */
  3002.     protected function mergeSurcharges(array $oldSurcharges)
  3003.     {
  3004.         foreach ($this->getItems() as $item) {
  3005.             if (!empty($oldSurcharges['items'][$item->getItemId() ?: spl_object_hash($item)])) {
  3006.                 $item->compareSurcharges($oldSurcharges['items'][$item->getItemId() ?: spl_object_hash($item)]);
  3007.             }
  3008.         }
  3010.         $this->compareSurcharges($oldSurcharges['surcharges']);
  3011.     }
  3013.     /**
  3014.      * Calculate initial order values
  3015.      *
  3016.      * @return void
  3017.      */
  3018.     public function calculateInitialValues()
  3019.     {
  3020.         $subtotal = 0;
  3022.         foreach ($this->getItems() as $item) {
  3023.             $item->calculate();
  3025.             $subtotal += $item->getSubtotal();
  3026.         }
  3028.         $subtotal = $this->getCurrency()->roundValue($subtotal);
  3030.         $this->setSubtotal($subtotal);
  3031.         $this->setTotal($subtotal);
  3032.     }
  3035.     /**
  3036.      * Finalize items calculation
  3037.      *
  3038.      * @return void
  3039.      */
  3040.     protected function finalizeItemsCalculation()
  3041.     {
  3042.         $subtotal = 0;
  3043.         foreach ($this->getItems() as $item) {
  3044.             $itemTotal = $item->calculateTotal();
  3045.             $subtotal += $itemTotal;
  3046.             $item->setTotal($itemTotal);
  3047.         }
  3049.         $this->setSubtotal($subtotal);
  3050.         $this->setTotal($subtotal);
  3051.     }
  3053.     // }}}
  3055.     // {{{ Surcharges
  3057.     /**
  3058.      * Get surcharges by type
  3059.      *
  3060.      * @param string $type Surcharge type
  3061.      *
  3062.      * @return list<Surcharge>
  3063.      */
  3064.     public function getSurchargesByType($type = null)
  3065.     {
  3066.         if ($type) {
  3067.             $list = [];
  3068.             foreach ($this->getSurcharges() as $surcharge) {
  3069.                 if ($surcharge->getType() === $type) {
  3070.                     $list[] = $surcharge;
  3071.                 }
  3072.             }
  3073.         } else {
  3074.             $list = $this->getSurcharges();
  3075.         }
  3077.         return $list;
  3078.     }
  3080.     /**
  3081.      * Get surcharges subtotal with specified type
  3082.      *
  3083.      * @param string  $type    Surcharge type OPTIONAL
  3084.      * @param boolean $include Surcharge include flag OPTIONAL
  3085.      *
  3086.      * @return float
  3087.      */
  3088.     public function getSurchargesSubtotal($type = null, $include = null)
  3089.     {
  3090.         $subtotal = 0;
  3091.         $surcharges = $this->getSurchargesByType($type);
  3093.         foreach ($surcharges as $surcharge) {
  3094.             if ($surcharge->getAvailable() && ($include === null || $surcharge->getInclude() === $include)) {
  3095.                 $subtotal += $this->getCurrency()->roundValue($surcharge->getValue());
  3096.             }
  3097.         }
  3099.         return $subtotal;
  3100.     }
  3102.     /**
  3103.      * Get subtotal for displaying
  3104.      *
  3105.      * @return float
  3106.      */
  3107.     public function getDisplaySubtotal()
  3108.     {
  3109.         return $this->getSubtotal();
  3110.     }
  3112.     /**
  3113.      * Get surcharges total with specified type
  3114.      *
  3115.      * @param string $type Surcharge type OPTIONAL
  3116.      *
  3117.      * @return float
  3118.      */
  3119.     public function getSurchargesTotal($type = null)
  3120.     {
  3121.         return $this->getSubtotal() + $this->getSurchargesSubtotal($type, false);
  3122.     }
  3124.     // }}}
  3126.     // {{{ Lifecycle callbacks
  3128.     /**
  3129.      * Prepare order before remove operation
  3130.      *
  3131.      * @return void
  3132.      */
  3133.     public function prepareBeforeRemove()
  3134.     {
  3135.         $profile = $this->getProfile();
  3136.         $origProfile = $this->getOrigProfile();
  3138.         try {
  3139.             if ($profile && (!$origProfile || $profile->getProfileId() !== $origProfile->getProfileId())) {
  3140.                 \XLite\Core\Database::getRepo('XLite\Model\Profile')->delete($profile, false);
  3141.             }
  3142.         } catch (\Doctrine\ORM\EntityNotFoundException $e) {
  3143.         }
  3144.     }
  3146.     /**
  3147.      * Since Doctrine lifecycle callbacks do not allow to modify associations, we've added this method
  3148.      *
  3149.      * @param string $type Type of current operation
  3150.      *
  3151.      * @return void
  3152.      */
  3153.     public function prepareEntityBeforeCommit($type)
  3154.     {
  3155.         if ($type === static::ACTION_DELETE) {
  3156.             $this->setOldPaymentStatus(null);
  3157.             $this->setOldShippingStatus(null);
  3159.             $this->updateItemsSales(-1);
  3161.             $this->prepareBeforeRemove();
  3162.         }
  3163.     }
  3165.     // }}}
  3167.     // {{{ Change status routine
  3169.     /**
  3170.      * Get payment status code
  3171.      *
  3172.      * @return string
  3173.      */
  3174.     public function getPaymentStatusCode()
  3175.     {
  3176.         return $this->getPaymentStatus() && $this->getPaymentStatus()->getCode()
  3177.             ? $this->getPaymentStatus()->getCode()
  3178.             : '';
  3179.     }
  3181.     /**
  3182.      * Get shipping status code
  3183.      *
  3184.      * @return string
  3185.      */
  3186.     public function getShippingStatusCode()
  3187.     {
  3188.         return $this->getShippingStatus() && $this->getShippingStatus()->getCode()
  3189.             ? $this->getShippingStatus()->getCode()
  3190.             : '';
  3191.     }
  3193.     /**
  3194.      * Set payment status
  3195.      *
  3196.      * @param mixed $paymentStatus Payment status
  3197.      *
  3198.      * @return void
  3199.      */
  3200.     public function setPaymentStatus($paymentStatus = null)
  3201.     {
  3202.         $this->processStatus($paymentStatus, 'payment');
  3203.     }
  3205.     /**
  3206.      * Set shipping status
  3207.      *
  3208.      * @param mixed $shippingStatus Shipping status
  3209.      *
  3210.      * @return void
  3211.      */
  3212.     public function setShippingStatus($shippingStatus = null)
  3213.     {
  3214.         $this->processStatus($shippingStatus, 'shipping');
  3215.     }
  3217.     /**
  3218.      * Process order status
  3219.      *
  3220.      * @param mixed  $status Status
  3221.      * @param string $type   Type
  3222.      *
  3223.      * @return void
  3224.      */
  3225.     public function processStatus($status, $type)
  3226.     {
  3227.         static $cache = [];
  3229.         if (is_scalar($status)) {
  3230.             if (!isset($cache[$type][$status])) {
  3231.                 $requestedStatus = $status;
  3233.                 if (
  3234.                     is_int($status)
  3235.                     || (is_string($status)
  3236.                         && preg_match('/^[\d]+$/', $status)
  3237.                     )
  3238.                 ) {
  3239.                     $status = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\\' . ucfirst($type))
  3240.                         ->find($status);
  3241.                 } elseif (is_string($status)) {
  3242.                     $status = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\\' . ucfirst($type))
  3243.                         ->findOneByCode($status);
  3244.                 }
  3246.                 $cache[$type][$requestedStatus] = $status;
  3247.             } else {
  3248.                 $status = $cache[$type][$status];
  3249.             }
  3250.         }
  3252.         $this->statusIsSet = true;
  3254.         $this->{'old' . ucfirst($type) . 'Status'} = $this->{$type . 'Status'};
  3255.         $this->{$type . 'Status'} = $status;
  3256.     }
  3258.     /**
  3259.      * Check order statuses
  3260.      *
  3261.      * @return boolean
  3262.      */
  3263.     public function checkStatuses()
  3264.     {
  3265.         $changed = false;
  3266.         $em = Database::getEM();
  3268.         if ($this->statusIsSet) {
  3269.             $this->statusIsSet = false;
  3270.             $statusHandlers = [];
  3272.             foreach (['payment', 'shipping'] as $type) {
  3273.                 $status = $this->{$type . 'Status'};
  3274.                 $oldStatus = $this->{'old' . ucfirst($type) . 'Status'};
  3275.                 if (
  3276.                     $status
  3277.                     && $oldStatus
  3278.                     && $status->getId() !== $oldStatus->getId()
  3279.                 ) {
  3280.                     $em->addAfterFlushCallback(function () use ($oldStatus, $status, $type) {
  3281.                         \XLite\Core\OrderHistory::getInstance()->registerOrderChangeStatus(
  3282.                             $this->getOrderId(),
  3283.                             [
  3284.                                 'old'  => $oldStatus,
  3285.                                 'new'  => $status,
  3286.                                 'type' => $type,
  3287.                             ]
  3288.                         );
  3290.                         $this->processStatusAnyToAny($oldStatus, $status, $type);
  3291.                     });
  3293.                     $statusHandlers = array_merge(
  3294.                         $this->getStatusHandlers($oldStatus, $status, $type),
  3295.                         $statusHandlers
  3296.                     );
  3298.                     $changed = true;
  3299.                 } elseif (!$oldStatus) {
  3300.                     $this->{'old' . ucfirst($type) . 'Status'} = $this->{$type . 'Status'};
  3301.                 }
  3302.             }
  3304.             $em->addAfterFlushCallback(function () use ($changed, $statusHandlers) {
  3305.                 if ($changed) {
  3306.                     $this->checkInventory();
  3307.                 }
  3309.                 if ($statusHandlers) {
  3310.                     foreach (array_unique($statusHandlers) as $handler) {
  3311.                         $this->{'process' . ucfirst($handler)}();
  3312.                     }
  3313.                 }
  3315.                 foreach (['payment', 'shipping'] as $type) {
  3316.                     $this->{'old' . ucfirst($type) . 'Status'} = null;
  3317.                 }
  3319.                 if ($changed) {
  3320.                     if (
  3321.                         !$this->isNotificationSent
  3322.                         && $this->isNotificationsAllowed()
  3323.                         && $this->getOrderNumber()
  3324.                     ) {
  3325.                         \XLite\Core\Mailer::sendOrderChanged($this, $this->isIgnoreCustomerNotifications());
  3326.                     }
  3327.                 }
  3328.             });
  3329.         }
  3331.         return $changed;
  3332.     }
  3334.     /**
  3335.      * Check inventory
  3336.      *
  3337.      * @throws \Doctrine\ORM\OptimisticLockException
  3338.      */
  3339.     public function checkInventory()
  3340.     {
  3341.         $property = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\Property')->findOneBy(
  3342.             [
  3343.                 'paymentStatus'  => $this->paymentStatus,
  3344.                 'shippingStatus' => $this->shippingStatus,
  3345.             ]
  3346.         );
  3348.         $incStock = $property ? $property->getIncStock() : null;
  3349.         if ($incStock !== null) {
  3350.             $stokStatus = $this->getStockStatus();
  3352.             $oldIncStock = null;
  3353.             if ($stokStatus === 'increased') {
  3354.                 $oldIncStock = true;
  3355.             } elseif ($stokStatus === 'reduced') {
  3356.                 $oldIncStock = false;
  3357.             }
  3359.             if ($oldIncStock === null) {
  3360.                 $property    = \XLite\Core\Database::getRepo('XLite\Model\Order\Status\Property')->findOneBy(
  3361.                     [
  3362.                         'paymentStatus'  => $this->oldPaymentStatus,
  3363.                         'shippingStatus' => $this->oldShippingStatus,
  3364.                     ]
  3365.                 );
  3366.                 $oldIncStock = $property ? $property->getIncStock() : null;
  3367.             }
  3369.             if ($oldIncStock !== null && $incStock !== $oldIncStock) {
  3370.                 if ($incStock) {
  3371.                     $this->processIncrease();
  3372.                     $this->setStockStatus('increased');
  3373.                 } else {
  3374.                     $this->processDecrease();
  3375.                     $this->setStockStatus('reduced');
  3376.                 }
  3377.             }
  3378.         }
  3380.         $this->updateSales();
  3382.         \XLite\Core\Database::getEM()->flush();
  3383.     }
  3385.     /**
  3386.      * Transform attributes: remove relations between order item attributes and product attribute values
  3387.      * to avoid data lost after product attribute values modification
  3388.      *
  3389.      * @return void
  3390.      */
  3391.     public function transformItemsAttributes()
  3392.     {
  3393.         foreach ($this->getItems() as $item) {
  3394.             if ($item->hasAttributeValues()) {
  3395.                 foreach ($item->getAttributeValues() as $av) {
  3396.                     if ($av->getAttributeValue()) {
  3397.                         $attributeValue = $av->getAttributeValue();
  3398.                         $av->setName($attributeValue->getAttribute()->getName());
  3399.                         if (!($attributeValue instanceof \XLite\Model\AttributeValue\AttributeValueText)) {
  3400.                             $av->setValue($attributeValue->asString());
  3401.                         }
  3402.                         $av->setAttributeId($attributeValue->getAttribute()->getId());
  3403.                     }
  3404.                 }
  3405.             }
  3406.         }
  3407.     }
  3409.     /**
  3410.      * These handlers will be used in systemStatus1->...customStatus(es)..->systemStatus2 transition
  3411.      * by default, don't try to cast old statuses
  3412.      * @param string $type Type
  3413.      *
  3414.      * @return array
  3415.      */
  3416.     protected function getStatusHandlersForCast($type)
  3417.     {
  3418.         return [];
  3419.     }
  3421.     /**
  3422.      * Return base part of the certain "change status" handler name
  3423.      *
  3424.      * @param mixed  $oldStatus  Old order status
  3425.      * @param mixed  $newStatus  New order status
  3426.      * @param string $type Type
  3427.      *
  3428.      * @return string|array
  3429.      */
  3430.     protected function getStatusHandlers($oldStatus, $newStatus, $type)
  3431.     {
  3432.         $class = '\XLite\Model\Order\Status\\' . ucfirst($type);
  3434.         $oldCode = $oldStatus->getCode();
  3435.         $newCode = $newStatus->getCode();
  3436.         $statusHandlers = $class::getStatusHandlers();
  3438.         $result = [];
  3440.         if ($oldCode && $newCode && isset($statusHandlers[$oldCode][$newCode])) {
  3441.             $result = is_array($statusHandlers[$oldCode][$newCode])
  3442.                 ? array_unique($statusHandlers[$oldCode][$newCode])
  3443.                 : $statusHandlers[$oldCode][$newCode];
  3444.         }
  3446.         return $result;
  3447.     }
  3449.     /**
  3450.      * @param array $inStatusHandlers
  3451.      *
  3452.      * @return array
  3453.      */
  3454.     protected function getFlatStatuses($inStatusHandlers = [])
  3455.     {
  3456.         $flatStatuses = array_reduce($inStatusHandlers, static function ($a, $b) {
  3457.             return array_merge($a, (array) $b);
  3458.         }, []);
  3460.         return array_unique(array_merge(array_keys($flatStatuses), array_keys($inStatusHandlers)));
  3461.     }
  3463.     /**
  3464.      * A "change status" handler
  3465.      *
  3466.      * @return void
  3467.      */
  3468.     protected function processCheckout()
  3469.     {
  3470.     }
  3472.     /**
  3473.      * A "change status" handler
  3474.      *
  3475.      * @return void
  3476.      */
  3477.     protected function processDecrease()
  3478.     {
  3479.         $this->decreaseInventory();
  3480.     }
  3482.     /**
  3483.      * A "change status" handler
  3484.      *
  3485.      * @return void
  3486.      */
  3487.     protected function processUncheckout()
  3488.     {
  3489.     }
  3491.     /**
  3492.      * A "change status" handler
  3493.      *
  3494.      * @return void
  3495.      */
  3496.     protected function processQueue()
  3497.     {
  3498.     }
  3500.     /**
  3501.      * A "change status" handler
  3502.      *
  3503.      * @return void
  3504.      */
  3505.     protected function processAuthorize()
  3506.     {
  3507.         if ($this instanceof Cart) {
  3508.             $this->setIsNotificationsAllowedFlag(false);
  3509.         }
  3510.     }
  3512.     /**
  3513.      * A "change status" handler
  3514.      *
  3515.      * @return void
  3516.      * @throws \JsonException
  3517.      */
  3518.     protected function processProcess()
  3519.     {
  3520.         /** @var GmvTrackerDomain $gmvTracker */
  3521.         $gmvTracker = \XCart\Container::getContainer()->get(GmvTrackerDomain::class);
  3522.         $gmvOrderData = $gmvTracker->prepareOrderGmvData($this);
  3523.         $gmvTracker->saveOrderGmvData($gmvOrderData);
  3525.         if ($this->isNotificationsAllowed()) {
  3526.             \XLite\Core\Mailer::sendOrderProcessed($this, $this->isIgnoreCustomerNotifications());
  3527.         }
  3529.         $this->setIsNotificationSent(true);
  3530.     }
  3532.     /**
  3533.      * A "change status" handler
  3534.      *
  3535.      * @return void
  3536.      */
  3537.     protected function processShip()
  3538.     {
  3539.         if ($this->isNotificationsAllowed() && !$this->isIgnoreCustomerNotifications()) {
  3540.             \XLite\Core\Mailer::sendOrderShipped($this);
  3541.         }
  3543.         $this->setIsNotificationSent(true);
  3544.     }
  3546.     /**
  3547.      * A "change status" handler
  3548.      *
  3549.      * @return void
  3550.      */
  3551.     protected function processWaitingForApprove()
  3552.     {
  3553.         if ($this->isNotificationsAllowed() && !$this->isIgnoreCustomerNotifications()) {
  3554.             \XLite\Core\Mailer::sendOrderWaitingForApprove($this);
  3555.         }
  3557.         $this->setIsNotificationSent(true);
  3558.     }
  3560.     /**
  3561.      * A "change status" handler
  3562.      *
  3563.      * @return void
  3564.      */
  3565.     protected function processReleaseBackorder()
  3566.     {
  3567.         foreach ($this->getItems() as $item) {
  3568.             $item->releaseBackorder();
  3569.         }
  3570.     }
  3572.     /**
  3573.      * A "change status" handler
  3574.      *
  3575.      * @return void
  3576.      */
  3577.     protected function processIncrease()
  3578.     {
  3579.         $this->increaseInventory();
  3580.     }
  3582.     /**
  3583.      * A "change status" handler
  3584.      *
  3585.      * @return void
  3586.      */
  3587.     protected function processDecline()
  3588.     {
  3589.     }
  3591.     /**
  3592.      * A "change status" handler
  3593.      *
  3594.      * @return void
  3595.      */
  3596.     protected function processFail()
  3597.     {
  3598.         if ($this->isNotificationsAllowed() && $this->getOrderNumber()) {
  3599.             \XLite\Core\Mailer::sendOrderFailed($this, $this->isIgnoreCustomerNotifications());
  3600.         }
  3602.         $this->setIsNotificationSent(true);
  3603.     }
  3605.     /**
  3606.      * A "change status" handler
  3607.      *
  3608.      * @return void
  3609.      */
  3610.     protected function processCancel()
  3611.     {
  3612.         if ($this->isNotificationsAllowed()) {
  3613.             \XLite\Core\Mailer::sendOrderCanceled($this, $this->isIgnoreCustomerNotifications());
  3614.         }
  3616.         $this->setIsNotificationSent(true);
  3617.     }
  3619.     /**
  3620.      * Status change handler for the "any to any" event.
  3621.      * 1)Allows to run handlers on systemStatus1->...customStatus(es)..->systemStatus2 transition
  3622.      *   Attention! handlers must include internal checking to avoid double execution
  3623.      *
  3624.      * @param $oldStatus
  3625.      * @param $newStatus
  3626.      * @param $type
  3627.      */
  3628.     protected function processStatusAnyToAny($oldStatus, $newStatus, $type)
  3629.     {
  3630.         // here is the key point to decide if we try to find an old system status in order history
  3631.         $statusHandlers2Cast = $this->getStatusHandlersForCast($type);
  3633.         if (!$statusHandlers2Cast) {
  3634.             return;
  3635.         }
  3636.         // Transitions between these statuses are valued only
  3637.         $businessLogicStatuses = $this->getFlatStatuses($statusHandlers2Cast);
  3639.         $inOldCode = $oldStatus->getCode();
  3640.         $inNewCode = $newStatus->getCode();
  3642.         // cycle is used for performance only, 'continue' below avoids unnecessary code execution
  3643.         foreach ($statusHandlers2Cast as $oldCode2Deal => $newCodes2Deal) {
  3644.             if (
  3645.                 $oldCode2Deal === $inOldCode // exact handler will be returned/launched by getStatusHandlers, do nothing
  3646.                 || !in_array($inNewCode, array_keys($newCodes2Deal)) // nothing to deal with here
  3647.                 || in_array($inOldCode, $businessLogicStatuses) // take into account transition from custom statuses to business statuses only
  3648.             ) {
  3649.                 continue;
  3650.             }
  3652.             // find the nearest business(system) status code from order history
  3653.             $oldSystemBusinessCode = $this->getNearestOldBusinessCode($inOldCode, $businessLogicStatuses, $type);
  3655.             if (
  3656.                 $oldSystemBusinessCode !== $inOldCode
  3657.                 && isset($statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode])
  3658.             ) {
  3659.                 // We have found an old business code before a bunch of meaningless ones
  3660.                 $castHandlers = is_array($statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode])
  3661.                     ? array_unique($statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode])
  3662.                     : [$statusHandlers2Cast[$oldSystemBusinessCode][$inNewCode]];
  3664.                 foreach ($castHandlers as $castHandler) {
  3665.                     // here we run a handler for a cast oldBusinessStatus->...someStatuses...->newBusinessStatus transition
  3666.                     $methodOnStatusChange = 'process' . \Includes\Utils\Converter::convertToUpperCamelCase($castHandler);
  3667.                     if (method_exists($this, $methodOnStatusChange)) {
  3668.                         $this->$methodOnStatusChange();
  3669.                     }
  3670.                 }
  3671.                 // typecast old code only once
  3672.                 break;
  3673.             }
  3674.         }
  3675.     }
  3677.     /**
  3678.      * Find backwards the nearest old business(system) code before a bunch of non-business logic codes
  3679.      *
  3680.      * @param $meaninglessOldCode
  3681.      * @param $businessLogicStatuses
  3682.      * @param $type
  3683.      *
  3684.      * @return string
  3685.      */
  3686.     protected function getNearestOldBusinessCode($meaninglessOldCode, $businessLogicStatuses, $type)
  3687.     {
  3688.         // this shared static cache is supposed to be used in other functions in the future. use the key ['OrderHistoryEvents', $this->getOrderId()]
  3689.         $historyList = $this->executeCachedRuntime(function () {
  3690.             return \XLite\Core\Database::getRepo('XLite\Model\OrderHistoryEvents')->findAllByOrder($this) ?: [];
  3691.         }, ['OrderHistoryEvents', $this->getOrderId()]) ?: [];
  3693.         $eventCodeName = $type === 'payment' ? \XLite\Core\OrderHistory::CODE_CHANGE_PAYMENT_STATUS_ORDER : \XLite\Core\OrderHistory::CODE_CHANGE_SHIPPING_STATUS_ORDER;
  3694.         $historyList = array_filter($historyList, static function ($event) use ($eventCodeName) {
  3695.             return $event->getCode() === $eventCodeName;
  3696.         });
  3698.         foreach ($historyList as $event) {
  3699.             $oldOrderStatus = $event->getData()['oldStatusCode'];
  3700.             if (in_array($oldOrderStatus, $businessLogicStatuses)) {
  3701.                 return $oldOrderStatus;
  3702.             }
  3703.         }
  3705.         return $meaninglessOldCode;
  3706.     }
  3707.     // }}}
  3709.     // {{{ Inventory tracking
  3711.     /**
  3712.      * Increase / decrease item products inventory
  3713.      *
  3714.      * @param integer $sign Flag; "1" or "-1"
  3715.      *
  3716.      * @return void
  3717.      */
  3718.     protected function changeItemsInventory($sign)
  3719.     {
  3720.         $registerAsGroup = 1 < count($this->getItems());
  3721.         $data = [];
  3722.         foreach ($this->getItems() as $item) {
  3723.             $delta = $sign * $item->getAmount();
  3725.             if ($delta !== 0) {
  3726.                 $data[] = $this->getGroupedDataItem($item, $delta);
  3727.             }
  3728.         }
  3730.         if ($registerAsGroup) {
  3731.             \XLite\Core\OrderHistory::getInstance()->registerChangeAmountGrouped(
  3732.                 $this->getOrderId(),
  3733.                 $data
  3734.             );
  3735.         }
  3737.         foreach ($this->getItems() as $item) {
  3738.             $this->changeItemInventory($item, $sign, !$registerAsGroup);
  3739.         }
  3740.     }
  3742.     /**
  3743.      * Get grouped data item
  3744.      *
  3745.      * @param \XLite\Model\OrderItem    $item       Order item
  3746.      * @param integer                   $amount     Amount
  3747.      *
  3748.      * @return array
  3749.      */
  3750.     protected function getGroupedDataItem($item, $amount)
  3751.     {
  3752.         return [
  3753.             'item'      => $item,
  3754.             'amount'    => $item->getProduct()->getPublicAmount(),
  3755.             'delta'     => $amount,
  3756.         ];
  3757.     }
  3759.     /**
  3760.      * Increase / decrease item product inventory
  3761.      *
  3762.      * @param \XLite\Model\OrderItem $item      Order item
  3763.      * @param integer                $sign      Flag; "1" or "-1"
  3764.      * @param boolean                $register  Register in order history OPTIONAL
  3765.      *
  3766.      * @return integer
  3767.      */
  3768.     protected function changeItemInventory($item, $sign, $register = true)
  3769.     {
  3770.         $delta = $sign * $item->getAmount();
  3772.         $realDelta = $delta > 0 && $item->getBackorderedAmount() > 0
  3773.             ? $delta - $item->getBackorderedAmount()
  3774.             : $delta;
  3776.         if ($realDelta !== 0) {
  3777.             if ($register) {
  3778.                 $this->registerHistoryChangeItemAmount($item, $realDelta);
  3779.             }
  3780.             $item->changeAmount($realDelta);
  3781.         }
  3783.         return $realDelta;
  3784.     }
  3786.     /**
  3787.      * @param \XLite\Model\OrderItem $item
  3788.      * @param integer                $delta
  3789.      */
  3790.     protected function registerHistoryChangeItemAmount($item, $delta)
  3791.     {
  3792.         $history = \XLite\Core\OrderHistory::getInstance();
  3793.         $history->registerChangeAmount($this->getOrderId(), $item->getProduct(), $delta);
  3794.     }
  3796.     /**
  3797.      * Order processed: decrease products inventory
  3798.      *
  3799.      * @return void
  3800.      */
  3801.     protected function decreaseInventory()
  3802.     {
  3803.         $this->changeItemsInventory(-1);
  3804.     }
  3806.     /**
  3807.      * Order declined: increase products inventory
  3808.      *
  3809.      * @return void
  3810.      */
  3811.     protected function increaseInventory()
  3812.     {
  3813.         $this->changeItemsInventory(1);
  3814.     }
  3816.     // }}}
  3818.     // {{{ Order actions
  3820.     /**
  3821.      * Get allowed actions
  3822.      *
  3823.      * @return array
  3824.      */
  3825.     public function getAllowedActions()
  3826.     {
  3827.         return [];
  3828.     }
  3830.     /**
  3831.      * Get allowed payment actions
  3832.      *
  3833.      * @return array
  3834.      */
  3835.     public function getAllowedPaymentActions()
  3836.     {
  3837.         $actions = [];
  3839.         $transactions = $this->getPaymentTransactions();
  3841.         if ($transactions) {
  3842.             foreach ($transactions as $transaction) {
  3843.                 $processor = $transaction->getPaymentMethod()
  3844.                     ? $transaction->getPaymentMethod()->getProcessor()
  3845.                     : null;
  3847.                 if ($processor) {
  3848.                     $allowedTransactions = $processor->getAllowedTransactions();
  3850.                     foreach ($allowedTransactions as $transactionType) {
  3851.                         if ($processor->isTransactionAllowed($transaction, $transactionType)) {
  3852.                             $actions[$transactionType] = $transaction->getTransactionId();
  3853.                         }
  3854.                     }
  3855.                 }
  3856.             }
  3857.         }
  3859.         return $actions;
  3860.     }
  3862.     /**
  3863.      * Get array of payment transaction sums (how much is authorized, captured and refunded)
  3864.      *
  3865.      * @return array
  3866.      */
  3867.     public function getPaymentTransactionSums()
  3868.     {
  3869.         $paymentTransactionSums = $this->getRawPaymentTransactionSums();
  3871.         $lblAuth = (string) static::t('Authorized amount');
  3872.         $lblCapture = (string) static::t('Captured amount');
  3873.         $lblRefunded = (string) static::t('Refunded amount');
  3875.         $paymentTransactionSums = [
  3876.             $lblAuth     => $paymentTransactionSums['authorized'],
  3877.             $lblCapture  => $paymentTransactionSums['captured'],
  3878.             $lblRefunded => $paymentTransactionSums['refunded'],
  3879.         ];
  3881.         // Remove from array all zero sums
  3882.         foreach ($paymentTransactionSums as $k => $v) {
  3883.             if (0.01 >= $v) {
  3884.                 unset($paymentTransactionSums[$k]);
  3885.             }
  3886.         }
  3888.         return $paymentTransactionSums;
  3889.     }
  3891.     /**
  3892.      * Get array of raw payment transaction sums
  3893.      *
  3894.      * @param boolean $override Override cache OPTIONAL
  3895.      *
  3896.      * @return array
  3897.      */
  3898.     public function getRawPaymentTransactionSums($override = false)
  3899.     {
  3900.         if ($this->paymentTransactionSums === null || $override) {
  3901.             $transactions = $this->getPaymentTransactions();
  3903.             $this->paymentTransactionSums = [
  3904.                 'authorized' => 0,
  3905.                 'captured'   => 0,
  3906.                 'refunded'   => 0,
  3907.                 'sale'       => 0,
  3908.                 'blocked'    => 0,
  3909.             ];
  3911.             foreach ($transactions as $t) {
  3912.                 if ($t->isPersistent()) {
  3913.                     \XLite\Core\Database::getEM()->refresh($t);
  3914.                 }
  3915.                 $backendTransactions = $t->getBackendTransactions();
  3917.                 $authorized = 0;
  3919.                 if ($backendTransactions && count($backendTransactions) > 0) {
  3920.                     // By backend transactions
  3921.                     foreach ($backendTransactions as $bt) {
  3922.                         if ($bt->isCompleted()) {
  3923.                             switch ($bt->getType()) {
  3924.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_AUTH:
  3925.                                     $authorized += $bt->getValue();
  3926.                                     $this->paymentTransactionSums['blocked'] += $bt->getValue();
  3927.                                     break;
  3929.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_SALE:
  3930.                                     $this->paymentTransactionSums['blocked'] += $bt->getValue();
  3931.                                     $this->paymentTransactionSums['sale'] += $bt->getValue();
  3932.                                     break;
  3934.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE:
  3935.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE_PART:
  3936.                                     $this->paymentTransactionSums['captured'] += $bt->getValue();
  3937.                                     $authorized -= $bt->getValue();
  3938.                                     $this->paymentTransactionSums['sale'] += $bt->getValue();
  3939.                                     break;
  3941.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND:
  3942.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_PART:
  3943.                                     $this->paymentTransactionSums['refunded'] += $bt->getValue();
  3944.                                     $this->paymentTransactionSums['blocked'] -= $bt->getValue();
  3945.                                     $this->paymentTransactionSums['sale'] -= $bt->getValue();
  3946.                                     break;
  3948.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_MULTI:
  3949.                                     $this->paymentTransactionSums['refunded'] += $bt->getValue();
  3950.                                     $authorized -= $bt->getValue();
  3951.                                     $this->paymentTransactionSums['blocked'] -= $bt->getValue();
  3952.                                     $this->paymentTransactionSums['sale'] -= $bt->getValue();
  3953.                                     break;
  3955.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID:
  3956.                                 case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID_PART:
  3957.                                     $authorized -= $bt->getValue();
  3958.                                     $this->paymentTransactionSums['blocked'] -= $bt->getValue();
  3959.                                     break;
  3961.                                 default:
  3962.                             }
  3963.                         }
  3964.                     }
  3965.                 } else {
  3966.                     // By transaction
  3967.                     if ($t->isCompleted()) {
  3968.                         switch ($t->getType()) {
  3969.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_AUTH:
  3970.                                 $authorized += $t->getValue();
  3971.                                 $this->paymentTransactionSums['blocked'] += $t->getValue();
  3972.                                 break;
  3974.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_SALE:
  3975.                                 $this->paymentTransactionSums['blocked'] += $t->getValue();
  3976.                                 $this->paymentTransactionSums['sale'] += $t->getValue();
  3977.                                 break;
  3979.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE:
  3980.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE_PART:
  3981.                                 $this->paymentTransactionSums['captured'] += $t->getValue();
  3982.                                 $authorized -= $t->getValue();
  3983.                                 $this->paymentTransactionSums['sale'] += $t->getValue();
  3984.                                 break;
  3986.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND:
  3987.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_PART:
  3988.                                 $this->paymentTransactionSums['refunded'] += $t->getValue();
  3989.                                 $this->paymentTransactionSums['blocked'] -= $t->getValue();
  3990.                                 $this->paymentTransactionSums['sale'] -= $t->getValue();
  3991.                                 break;
  3993.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_REFUND_MULTI:
  3994.                                 $this->paymentTransactionSums['refunded'] += $t->getValue();
  3995.                                 $authorized -= $t->getValue();
  3996.                                 $this->paymentTransactionSums['blocked'] -= $t->getValue();
  3997.                                 $this->paymentTransactionSums['sale'] -= $t->getValue();
  3998.                                 break;
  4000.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID:
  4001.                             case \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_VOID_PART:
  4002.                                 $authorized -= $t->getValue();
  4003.                                 $this->paymentTransactionSums['blocked'] -= $t->getValue();
  4004.                                 break;
  4006.                             default:
  4007.                         }
  4008.                     }
  4009.                 }
  4011.                 if (
  4012.                     0 < $authorized
  4013.                     && 0 < $this->paymentTransactionSums['captured']
  4014.                     && !$t->getPaymentMethod()->getProcessor()->isTransactionAllowed($t, \XLite\Model\Payment\BackendTransaction::TRAN_TYPE_CAPTURE_MULTI)
  4015.                 ) {
  4016.                     // Do not take in consideration an authorized sum after capture
  4017.                     // if payment processor does not support multiple partial capture transactions
  4018.                     $authorized = 0;
  4019.                 }
  4021.                 $this->paymentTransactionSums['authorized'] += $authorized;
  4022.             } // foreach
  4024.             $this->paymentTransactionSums = array_map(function ($item) {
  4025.                 return $this->getCurrency()->roundValue($item);
  4026.             }, $this->paymentTransactionSums);
  4027.         }
  4029.         return $this->paymentTransactionSums;
  4030.     }
  4032.     // }}}
  4034.     // {{{ Common for several pages method to use in invoice templates
  4036.     /**
  4037.      * Return true if shipping section should be visible on the invoice
  4038.      *
  4039.      * @return boolean
  4040.      */
  4041.     public function isShippingSectionVisible()
  4042.     {
  4043.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  4045.         return $modifier && $modifier->canApply();
  4046.     }
  4048.     /**
  4049.      * Return true if payment section should be visible on the invoice
  4050.      * (this section is always visible by the default)
  4051.      *
  4052.      * @return boolean
  4053.      */
  4054.     public function isPaymentSectionVisible()
  4055.     {
  4056.         return true;
  4057.     }
  4059.     /**
  4060.      * Return true if payment and/or shipping sections should be visible on the invoice
  4061.      *
  4062.      * @return boolean
  4063.      */
  4064.     public function isPaymentShippingSectionVisible()
  4065.     {
  4066.         return $this->isShippingSectionVisible() || $this->isPaymentSectionVisible();
  4067.     }
  4069.     // }}}
  4071.     /**
  4072.      * Renew payment status.
  4073.      * Return true if payment status has been changed
  4074.      *
  4075.      * @return boolean
  4076.      */
  4077.     public function renewPaymentStatus()
  4078.     {
  4079.         $result = false;
  4081.         $status = $this->getCalculatedPaymentStatus(true);
  4082.         if ($this->getPaymentStatusCode() !== $status) {
  4083.             $this->setPaymentStatus($status);
  4084.             $result = true;
  4085.         }
  4087.         return $result;
  4088.     }
  4090.     /**
  4091.      * Get calculated payment status
  4092.      *
  4093.      * @param boolean $override Override calculation cache OPTIONAL
  4094.      *
  4095.      * @return string
  4096.      */
  4097.     public function getCalculatedPaymentStatus($override = false)
  4098.     {
  4099.         $result = \XLite\Model\Order\Status\Payment::STATUS_QUEUED;
  4101.         $sums = $this->getRawPaymentTransactionSums($override);
  4102.         $total = $this->getCurrency()->roundValue($this->getTotal());
  4104.         if ($total == 0.0) {
  4105.             $result = \XLite\Model\Order\Status\Payment::STATUS_PAID;
  4106.         } elseif ($sums['authorized'] > 0 && $sums['sale'] == 0 && $sums['captured'] == 0) {
  4107.             $result = \XLite\Model\Order\Status\Payment::STATUS_AUTHORIZED;
  4108.         } elseif ($sums['sale'] < $total) {
  4109.             if ($sums['sale'] > 0) {
  4110.                 $result = \XLite\Model\Order\Status\Payment::STATUS_PART_PAID;
  4111.             } elseif ($sums['refunded'] > 0) {
  4112.                 $result = \XLite\Model\Order\Status\Payment::STATUS_REFUNDED;
  4113.             }
  4114.         } else {
  4115.             if ($sums['sale'] > 0 || $sums['captured'] > 0) {
  4116.                 $result = \XLite\Model\Order\Status\Payment::STATUS_PAID;
  4117.             } elseif ($sums['refunded'] > 0) {
  4118.                 $result = \XLite\Model\Order\Status\Payment::STATUS_REFUNDED;
  4119.             }
  4120.         }
  4122.         $lastTransaction = $this->getPaymentTransactions()->last();
  4123.         if ($lastTransaction && $lastTransaction->isVoid()) {
  4124.             $result = \XLite\Model\Order\Status\Payment::STATUS_CANCELED;
  4125.         }
  4127.         if ($result === \XLite\Model\Order\Status\Payment::STATUS_QUEUED) {
  4128.             if ($lastTransaction) {
  4129.                 if ($lastTransaction->isFailed() || $lastTransaction->isVoid()) {
  4130.                     $result = \XLite\Model\Order\Status\Payment::STATUS_DECLINED;
  4131.                 }
  4133.                 if ($lastTransaction->isCanceled()) {
  4134.                     $result = \XLite\Model\Order\Status\Payment::STATUS_CANCELED;
  4135.                 }
  4136.             }
  4137.         }
  4139.         return $result;
  4140.     }
  4142.     /**
  4143.      * Set order status by transaction
  4144.      *
  4145.      * @param \XLite\Model\Payment\Transaction $transaction Transaction which changes status
  4146.      *
  4147.      * @return void
  4148.      */
  4149.     public function setPaymentStatusByTransaction(\XLite\Model\Payment\Transaction $transaction)
  4150.     {
  4151.         if ($this->isPayed()) {
  4152.             $status = $transaction->isCaptured()
  4153.                 ? \XLite\Model\Order\Status\Payment::STATUS_PAID
  4154.                 : \XLite\Model\Order\Status\Payment::STATUS_AUTHORIZED;
  4155.         } else {
  4156.             if ($transaction->isRefunded()) {
  4157.                 $paymentTransactionSums = $this->getRawPaymentTransactionSums(true);
  4158.                 $refunded = $paymentTransactionSums['refunded'];
  4160.                 // Check if the whole refunded sum (along with the previous refunded transactions for the order)
  4161.                 // covers the whole total for order
  4162.                 $status = $this->getCurrency()->roundValue($refunded) < $this->getCurrency()->roundValue($this->getTotal())
  4163.                     ? \XLite\Model\Order\Status\Payment::STATUS_PART_PAID
  4164.                     : \XLite\Model\Order\Status\Payment::STATUS_REFUNDED;
  4165.             } elseif ($transaction->isFailed()) {
  4166.                 $status = \XLite\Model\Order\Status\Payment::STATUS_DECLINED;
  4167.             } elseif ($transaction->isVoid()) {
  4168.                 $status = \XLite\Model\Order\Status\Payment::STATUS_CANCELED;
  4169.             } elseif ($transaction->isCaptured()) {
  4170.                 $status = \XLite\Model\Order\Status\Payment::STATUS_PART_PAID;
  4171.             } else {
  4172.                 $status = \XLite\Model\Order\Status\Payment::STATUS_QUEUED;
  4173.             }
  4174.         }
  4176.         $this->setPaymentStatus($status);
  4177.     }
  4179.     /**
  4180.      * Checks whether order is shippable or not
  4181.      *
  4182.      * @return boolean
  4183.      */
  4184.     public function isShippable()
  4185.     {
  4186.         $result = false;
  4188.         foreach ($this->getItems() as $item) {
  4189.             if ($item->isShippable()) {
  4190.                 $result = true;
  4191.                 break;
  4192.             }
  4193.         }
  4195.         return $result;
  4196.     }
  4198.     /**
  4199.      * Get addresses list
  4200.      *
  4201.      * @return array
  4202.      */
  4203.     public function getAddresses()
  4204.     {
  4205.         $list = $this->getProfile()->getAddresses()->toArray();
  4206.         if ($this->getOrigProfile()) {
  4207.             foreach ($this->getOrigProfile()->getAddresses() as $address) {
  4208.                 $equal = false;
  4209.                 foreach ($list as $address2) {
  4210.                     if (!$equal && $address->isEqualAddress($address2)) {
  4211.                         $equal = true;
  4212.                         break;
  4213.                     }
  4214.                 }
  4216.                 if (!$equal) {
  4217.                     $list[] = $address;
  4218.                 }
  4219.             }
  4220.         }
  4222.         return $list;
  4223.     }
  4225.     /**
  4226.      * Check if all order items in order is valid
  4227.      *
  4228.      * @return boolean
  4229.      */
  4230.     protected function isAllItemsValid()
  4231.     {
  4232.         $result = true;
  4234.         foreach ($this->getItems() as $item) {
  4235.             if (!$item->isValid()) {
  4236.                 $result = false;
  4237.                 break;
  4238.             }
  4239.         }
  4241.         return $result;
  4242.     }
  4244.     /**
  4245.      * Check if all order items in order is configured
  4246.      *
  4247.      * @return boolean
  4248.      */
  4249.     protected function isConfigured()
  4250.     {
  4251.         $isConfigured = true;
  4253.         foreach ($this->getItems() as $item) {
  4254.             if (!$item->isConfigured()) {
  4255.                 $isConfigured = false;
  4256.                 break;
  4257.             }
  4258.         }
  4260.         return $isConfigured;
  4261.     }
  4263.     /**
  4264.      * Get payment transaction data.
  4265.      * These data are displayed on the order page, invoice and packing slip
  4266.      *
  4267.      * @param boolean $isPrimary Flag: true - return only data fields marked by processor as 'primary', false - all fields OPTIONAL
  4268.      *
  4269.      * @return array
  4270.      */
  4271.     public function getPaymentTransactionData($isPrimary = false)
  4272.     {
  4273.         $result = [];
  4275.         $transaction = $this->getPaymentTransactions()
  4276.             ? $this->getPaymentTransactions()->last()
  4277.             : null;
  4279.         if ($transaction) {
  4280.             $method = $transaction->getPaymentMethod() ?: $this->getPaymentMethod();
  4281.             $processor = $method ? $method->getProcessor() : null;
  4283.             if ($processor) {
  4284.                 $result = $processor->getTransactionData($transaction, $isPrimary);
  4285.             }
  4286.         }
  4288.         return $result;
  4289.     }
  4291.     /**
  4292.      * Get last payment transaction ID.
  4293.      * This data is displayed on the order page, invoice and packing slip
  4294.      *
  4295.      * @return string|null
  4296.      */
  4297.     public function getPaymentTransactionId()
  4298.     {
  4299.         $transaction = $this->getPaymentTransactions()
  4300.             ? $this->getPaymentTransactions()->last()
  4301.             : null;
  4303.         return $transaction
  4304.             ? $transaction->getPublicId()
  4305.             : null;
  4306.     }
  4308.     /**
  4309.      * @return bool
  4310.      */
  4311.     public function isOfflineProcessorUsed()
  4312.     {
  4313.         $processor = $this->getPaymentProcessor();
  4315.         return $processor instanceof \XLite\Model\Payment\Processor\Offline;
  4316.     }
  4318.     /**
  4319.      * @return \XLite\Model\Payment\Base\Processor
  4320.      */
  4321.     public function getPaymentProcessor()
  4322.     {
  4323.         $processor = null;
  4325.         $transaction = $this->getPaymentTransactions()
  4326.             ? $this->getPaymentTransactions()->last()
  4327.             : null;
  4329.         if ($transaction) {
  4330.             $method = $transaction->getPaymentMethod() ?: $this->getPaymentMethod();
  4331.             $processor = $method ? $method->getProcessor() : null;
  4332.         }
  4334.         return $processor;
  4335.     }
  4337.     // {{{ Sales statistic
  4339.     /**
  4340.      * Returns old payment status code
  4341.      *
  4342.      * @return string
  4343.      */
  4344.     protected function getOldPaymentStatusCode()
  4345.     {
  4346.         $oldPaymentStatus = $this->oldPaymentStatus;
  4348.         return $oldPaymentStatus && $oldPaymentStatus->getCode()
  4349.             ? $oldPaymentStatus->getCode()
  4350.             : '';
  4351.     }
  4353.     /**
  4354.      * Calculate sales delta
  4355.      *
  4356.      * @return integer|null
  4357.      */
  4358.     protected function getSalesDelta()
  4359.     {
  4360.         $result = null;
  4362.         $newStatusCode = $this->getPaymentStatusCode();
  4363.         if ($newStatusCode) {
  4364.             $oldStatusCode = $this->getOldPaymentStatusCode();
  4365.             $paidStatuses = \XLite\Model\Order\Status\Payment::getPaidStatuses();
  4367.             if (
  4368.                 (!$oldStatusCode || !in_array($oldStatusCode, $paidStatuses, true))
  4369.                 && in_array($newStatusCode, $paidStatuses, true)
  4370.             ) {
  4371.                 $result = 1;
  4372.             } elseif (
  4373.                 $oldStatusCode
  4374.                 && in_array($oldStatusCode, $paidStatuses, true)
  4375.                 && !in_array($newStatusCode, $paidStatuses, true)
  4376.             ) {
  4377.                 $result = -1;
  4378.             }
  4379.         }
  4381.         return $result;
  4382.     }
  4384.     /**
  4385.      * Update sales statistics
  4386.      *
  4387.      * @param integer $delta Delta
  4388.      */
  4389.     protected function updateItemsSales($delta)
  4390.     {
  4391.         if ($delta === null) {
  4392.             return;
  4393.         }
  4395.         foreach ($this->getItems() as $item) {
  4396.             $product = $item->getObject();
  4397.             if ($product === null) {
  4398.                 continue;
  4399.             }
  4401.             $product->setSales(
  4402.                 $product->getSales() + $delta * $item->getAmount()
  4403.             );
  4404.         }
  4405.     }
  4407.     /**
  4408.      * Update sales
  4409.      */
  4410.     protected function updateSales()
  4411.     {
  4412.         $this->updateItemsSales($this->getSalesDelta());
  4413.     }
  4415.     // }}}
  4417.     /**
  4418.      * Get order_id
  4419.      *
  4420.      * @return integer
  4421.      */
  4422.     public function getOrderId()
  4423.     {
  4424.         return $this->order_id;
  4425.     }
  4427.     public function getPublicId(): ?string
  4428.     {
  4429.         return $this->public_id;
  4430.     }
  4432.     /**
  4433.      * Cannot be strict `string` type as there are 'public_id=null' orders after upgrade. #XCB-2685
  4434.      */
  4435.     public function setPublicId(?string $public_id): void
  4436.     {
  4437.         $this->public_id = $public_id;
  4438.     }
  4440.     /**
  4441.      * Set shipping_id
  4442.      *
  4443.      * @param integer $shippingId
  4444.      * @return Order
  4445.      */
  4446.     public function setShippingId($shippingId)
  4447.     {
  4448.         $this->shipping_id = $shippingId;
  4449.         return $this;
  4450.     }
  4452.     /**
  4453.      * Get shipping_id
  4454.      *
  4455.      * @return integer
  4456.      */
  4457.     public function getShippingId()
  4458.     {
  4459.         return $this->shipping_id;
  4460.     }
  4462.     /**
  4463.      * Set shipping_method_name
  4464.      *
  4465.      * @param string $shippingMethodName
  4466.      * @return Order
  4467.      */
  4468.     public function setShippingMethodName($shippingMethodName)
  4469.     {
  4470.         $this->shipping_method_name = $shippingMethodName;
  4471.         return $this;
  4472.     }
  4474.     /**
  4475.      * Set payment_method_name
  4476.      *
  4477.      * @param string $paymentMethodName
  4478.      * @return Order
  4479.      */
  4480.     public function setPaymentMethodName($paymentMethodName)
  4481.     {
  4482.         $this->payment_method_name = $paymentMethodName;
  4483.         return $this;
  4484.     }
  4486.     /**
  4487.      * Set tracking
  4488.      *
  4489.      * @param string $tracking
  4490.      * @return Order
  4491.      */
  4492.     public function setTracking($tracking)
  4493.     {
  4494.         $this->tracking = $tracking;
  4495.         return $this;
  4496.     }
  4498.     /**
  4499.      * Get tracking
  4500.      *
  4501.      * @return string
  4502.      */
  4503.     public function getTracking()
  4504.     {
  4505.         return $this->tracking;
  4506.     }
  4508.     /**
  4509.      * Set date
  4510.      *
  4511.      * @param integer $date
  4512.      * @return Order
  4513.      */
  4514.     public function setDate($date)
  4515.     {
  4516.         $this->date = $date;
  4517.         return $this;
  4518.     }
  4520.     /**
  4521.      * Get date
  4522.      *
  4523.      * @return integer
  4524.      */
  4525.     public function getDate()
  4526.     {
  4527.         return $this->date;
  4528.     }
  4530.     /**
  4531.      * Set lastRenewDate
  4532.      *
  4533.      * @param integer $lastRenewDate
  4534.      * @return Order
  4535.      */
  4536.     public function setLastRenewDate($lastRenewDate)
  4537.     {
  4538.         $this->lastRenewDate = $lastRenewDate;
  4539.         return $this;
  4540.     }
  4542.     /**
  4543.      * Get lastRenewDate
  4544.      *
  4545.      * @return integer
  4546.      */
  4547.     public function getLastRenewDate()
  4548.     {
  4549.         return $this->lastRenewDate;
  4550.     }
  4552.     /**
  4553.      * Set notes
  4554.      *
  4555.      * @param string $notes
  4556.      *
  4557.      * @return Order
  4558.      */
  4559.     public function setNotes($notes)
  4560.     {
  4561.         $this->notes = $notes;
  4562.         return $this;
  4563.     }
  4565.     /**
  4566.      * Get notes
  4567.      *
  4568.      * @return string
  4569.      */
  4570.     public function getNotes()
  4571.     {
  4572.         return $this->notes;
  4573.     }
  4575.     /**
  4576.      * Set adminNotes
  4577.      *
  4578.      * @param string $adminNotes
  4579.      *
  4580.      * @return Order
  4581.      */
  4582.     public function setAdminNotes($adminNotes)
  4583.     {
  4584.         $this->adminNotes = $adminNotes;
  4585.         return $this;
  4586.     }
  4588.     /**
  4589.      * Get adminNotes
  4590.      *
  4591.      * @return string
  4592.      */
  4593.     public function getAdminNotes()
  4594.     {
  4595.         return $this->adminNotes;
  4596.     }
  4598.     public function getSalesChannel(): ?string
  4599.     {
  4600.         return $this->salesChannel;
  4601.     }
  4603.     public function setSalesChannel(?string $salesChannel): Order
  4604.     {
  4605.         $this->salesChannel = $salesChannel;
  4607.         return $this;
  4608.     }
  4610.     /**
  4611.      * Set orderNumber
  4612.      *
  4613.      * @param string $orderNumber
  4614.      * @return Order
  4615.      */
  4616.     public function setOrderNumber($orderNumber)
  4617.     {
  4618.         $this->orderNumber = $orderNumber;
  4619.         return $this;
  4620.     }
  4622.     /**
  4623.      * Get orderNumber
  4624.      *
  4625.      * @return string
  4626.      */
  4627.     public function getOrderNumber()
  4628.     {
  4629.         return $this->orderNumber;
  4630.     }
  4632.     /**
  4633.      * Set recent
  4634.      *
  4635.      * @param boolean $recent
  4636.      * @return Order
  4637.      */
  4638.     public function setRecent($recent)
  4639.     {
  4640.         $this->recent = $recent;
  4641.         return $this;
  4642.     }
  4644.     /**
  4645.      * Get recent
  4646.      *
  4647.      * @return boolean
  4648.      */
  4649.     public function getRecent()
  4650.     {
  4651.         return $this->recent;
  4652.     }
  4654.     /**
  4655.      * Set xcPendingExport
  4656.      *
  4657.      * @param boolean $xcPendingExport
  4658.      * @return Order
  4659.      */
  4660.     public function setXcPendingExport($xcPendingExport)
  4661.     {
  4662.         $this->xcPendingExport = $xcPendingExport;
  4663.         return $this;
  4664.     }
  4666.     /**
  4667.      * Get xcPendingExport
  4668.      *
  4669.      * @return boolean
  4670.      */
  4671.     public function getXcPendingExport()
  4672.     {
  4673.         return $this->xcPendingExport;
  4674.     }
  4676.     /**
  4677.      * Return BackorderCompetitors
  4678.      *
  4679.      * @return ArrayCollection
  4680.      */
  4681.     public function getBackorderCompetitors()
  4682.     {
  4683.         return $this->backorderCompetitors;
  4684.     }
  4686.     /**
  4687.      * Set BackorderCompetitors
  4688.      *
  4689.      * @param Order[] $backorderCompetitors
  4690.      *
  4691.      * @return $this
  4692.      */
  4693.     public function setBackorderCompetitors($backorderCompetitors)
  4694.     {
  4695.         $this->backorderCompetitors = $backorderCompetitors;
  4696.         return $this;
  4697.     }
  4699.     /**
  4700.      * Get total
  4701.      *
  4702.      * @return float
  4703.      */
  4704.     public function getTotal()
  4705.     {
  4706.         return $this->total;
  4707.     }
  4709.     /**
  4710.      * Get subtotal
  4711.      *
  4712.      * @return float
  4713.      */
  4714.     public function getSubtotal()
  4715.     {
  4716.         return $this->subtotal;
  4717.     }
  4719.     /**
  4720.      * Get profile
  4721.      *
  4722.      * @return \XLite\Model\Profile
  4723.      */
  4724.     public function getProfile()
  4725.     {
  4726.         return $this->profile;
  4727.     }
  4729.     /**
  4730.      * Get orig_profile
  4731.      *
  4732.      * @return \XLite\Model\Profile
  4733.      */
  4734.     public function getOrigProfile()
  4735.     {
  4736.         return $this->orig_profile;
  4737.     }
  4739.     /**
  4740.      * Get paymentStatus
  4741.      *
  4742.      * @return \XLite\Model\Order\Status\Payment
  4743.      */
  4744.     public function getPaymentStatus()
  4745.     {
  4746.         return $this->paymentStatus;
  4747.     }
  4749.     /**
  4750.      * Get shippingStatus
  4751.      *
  4752.      * @return \XLite\Model\Order\Status\Shipping
  4753.      */
  4754.     public function getShippingStatus()
  4755.     {
  4756.         return $this->shippingStatus;
  4757.     }
  4759.     /**
  4760.      * Add details
  4761.      *
  4762.      * @param \XLite\Model\OrderDetail $details
  4763.      * @return Order
  4764.      */
  4765.     public function addDetails(\XLite\Model\OrderDetail $details)
  4766.     {
  4767.         $this->details[] = $details;
  4768.         return $this;
  4769.     }
  4771.     /**
  4772.      * Get details
  4773.      *
  4774.      * @return \Doctrine\Common\Collections\Collection|\XLite\Model\OrderDetail[]
  4775.      */
  4776.     public function getDetails()
  4777.     {
  4778.         return $this->details;
  4779.     }
  4781.     /**
  4782.      * Add trackingNumbers
  4783.      *
  4784.      * @param \XLite\Model\OrderTrackingNumber $trackingNumbers
  4785.      * @return Order
  4786.      */
  4787.     public function addTrackingNumbers(\XLite\Model\OrderTrackingNumber $trackingNumbers)
  4788.     {
  4789.         $this->trackingNumbers[] = $trackingNumbers;
  4790.         return $this;
  4791.     }
  4793.     /**
  4794.      * Get trackingNumbers
  4795.      *
  4796.      * @return \Doctrine\Common\Collections\Collection
  4797.      */
  4798.     public function getTrackingNumbers()
  4799.     {
  4800.         return $this->trackingNumbers;
  4801.     }
  4803.     /**
  4804.      * Add events
  4805.      *
  4806.      * @param \XLite\Model\OrderHistoryEvents $events
  4807.      * @return Order
  4808.      */
  4809.     public function addEvents(\XLite\Model\OrderHistoryEvents $events)
  4810.     {
  4811.         $this->events[] = $events;
  4812.         return $this;
  4813.     }
  4815.     /**
  4816.      * Get events
  4817.      *
  4818.      * @return \Doctrine\Common\Collections\Collection
  4819.      */
  4820.     public function getEvents()
  4821.     {
  4822.         return $this->events;
  4823.     }
  4825.     /**
  4826.      * Add item
  4827.      *
  4828.      * @param \XLite\Model\OrderItem $item
  4829.      * @return Order
  4830.      */
  4831.     public function addItems(\XLite\Model\OrderItem $item)
  4832.     {
  4833.         $this->items[] = $item;
  4834.         return $this;
  4835.     }
  4837.     /**
  4838.      * Get items
  4839.      *
  4840.      * @return list<OrderItem>
  4841.      */
  4842.     public function getItems()
  4843.     {
  4844.         return $this->items;
  4845.     }
  4847.     /**
  4848.      * Add surcharges
  4849.      *
  4850.      * @param \XLite\Model\Order\Surcharge $surcharges
  4851.      * @return Order
  4852.      */
  4853.     public function addSurcharges(\XLite\Model\Order\Surcharge $surcharges)
  4854.     {
  4855.         $this->surcharges[] = $surcharges;
  4856.         return $this;
  4857.     }
  4859.     /**
  4860.      * Get surcharges
  4861.      *
  4862.      * @return \Doctrine\Common\Collections\Collection
  4863.      */
  4864.     public function getSurcharges()
  4865.     {
  4866.         return $this->surcharges;
  4867.     }
  4869.     /**
  4870.      * Add payment_transactions
  4871.      *
  4872.      * @param \XLite\Model\Payment\Transaction $paymentTransactions
  4873.      * @return Order
  4874.      */
  4875.     public function addPaymentTransactions(\XLite\Model\Payment\Transaction $paymentTransactions)
  4876.     {
  4877.         $this->payment_transactions[] = $paymentTransactions;
  4878.         return $this;
  4879.     }
  4881.     /**
  4882.      * Get payment_transactions
  4883.      *
  4884.      * @return \Doctrine\Common\Collections\Collection|\XLite\Model\Payment\Transaction[]
  4885.      */
  4886.     public function getPaymentTransactions()
  4887.     {
  4888.         $result = $this->payment_transactions;
  4890.         $compare = static function ($a, $b) {
  4891.             /** @var \XLite\Model\Payment\Transaction $a */
  4892.             /** @var \XLite\Model\Payment\Transaction $b */
  4893.             return ($a->getTransactionId() < $b->getTransactionId()) ? -1 : 1;
  4894.         };
  4896.         if ($result instanceof \Doctrine\Common\Collections\Collection) {
  4897.             $iterator = $result->getIterator();
  4898.             $iterator->uasort($compare);
  4900.             foreach ($iterator as $key => $item) {
  4901.                 $result->set($key, $item);
  4902.             }
  4903.         } elseif (is_array($result)) {
  4904.             uasort($result, $compare);
  4905.         }
  4907.         return $result;
  4908.     }
  4910.     /**
  4911.      * Set currency
  4912.      *
  4913.      * @param \XLite\Model\Currency $currency
  4914.      * @return Order
  4915.      */
  4916.     public function setCurrency(\XLite\Model\Currency $currency = null)
  4917.     {
  4918.         $this->currency = $currency;
  4919.         return $this;
  4920.     }
  4922.     /**
  4923.      * Get currency
  4924.      *
  4925.      * @return \XLite\Model\Currency
  4926.      */
  4927.     public function getCurrency()
  4928.     {
  4929.         return $this->currency;
  4930.     }
  4932.     /**
  4933.      * Check - block Paid is visible or not
  4934.      *
  4935.      * @return boolean
  4936.      */
  4937.     protected function blockPaidIsVisible()
  4938.     {
  4939.         return $this->getPaidTotal() > 0
  4940.             && $this->getOpenTotal() >= 0;
  4941.     }
  4943.     /**
  4944.      * Remember last shipping id
  4945.      *
  4946.      * @return bool
  4947.      */
  4948.     public function updateEmptyShippingID()
  4949.     {
  4950.         if (!$this->getShippingId() && $this->getProfile() && $this->getLastShippingId()) {
  4951.             $this->setShippingId($this->getLastShippingId());
  4952.             return true;
  4953.         }
  4955.         return false;
  4956.     }
  4958.     public function getSalesChannelBackground(): ?string
  4959.     {
  4960.         return '#F5F5F5';
  4961.     }
  4963.     public function hasZeroCostRate()
  4964.     {
  4965.         $currency = $this->getCurrency();
  4966.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  4967.         $rates = $modifier->getRates();
  4969.         foreach ($rates as $rate) {
  4970.             if ($rate->isZeroCost($currency)) {
  4971.                 return true;
  4972.             }
  4973.         }
  4975.         return false;
  4976.     }
  4978.     public function isCurrentRateZero()
  4979.     {
  4980.         $currency = $this->getCurrency();
  4981.         $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING');
  4982.         $rates = $modifier->getRates();
  4984.         $currentRate = $modifier->getSelectedRate() ?? reset($rates);
  4985.         if ($currentRate->isZeroCost($currency)) {
  4986.             return true;
  4987.         }
  4989.         return false;
  4990.     }
  4992.     /**
  4993.      * Show free shipping note
  4994.      *
  4995.      * @return boolean
  4996.      */
  4997.     public function showFreeShippingNote()
  4998.     {
  4999.         if (!\XLite\Core\Config::getInstance()->General->display_free_shipping_note) {
  5000.             return false;
  5001.         }
  5003.         if ($this->hasZeroCostRate() && !$this->isCurrentRateZero()) {
  5004.             return true;
  5005.         }
  5007.         return false;
  5008.     }
  5009. }