classes/XLite/Model/Order.php line 80

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