orderarchiveitem.php

<?php
namespace Bitrix\Sale\Archive\Process;
 
use Bitrix\Main,
    Bitrix\Main\Type,
    Bitrix\Main\Localization\Loc,
    Bitrix\Sale,
    Bitrix\Sale\Internals,
    Bitrix\Sale\Archive\Manager;
 
Loc::loadMessages(__FILE__);
 
class OrderArchiveItem
{
    private $order = null;
    private $orderDataFields = [];
    private $basketDataFields = [];
 
    public function __construct(Sale\Order $order)
    {
        $this->order = $order;
        $this->orderDataFields['ORDER'] = $order->getFieldValues();
    }
 
    public function getId()
    {
        return $this->order->getId();
    }
 
    public function addOrderDataField($name, array $value)
    {
        if ($name !== 'ORDER')
        {
            $this->orderDataFields[$name] = $value;
        }
    }
 
    public function addBasketDataFields(array $value)
    {
        $this->basketDataFields = $value;
    }
 
    public function archive()
    {
        $r = $this->callEventOnBeforeOrderArchived($this->order);
        if (!$r->isSuccess())
        {
            return $r;
        }
 
        $result = $this->saveOrderArchive();
        if ($result->isSuccess())
        {
            $archivedOrderId = $result->getId();
            $basketItemIdList = array();
            foreach ($this->basketDataFields as $basketItem)
            {
                $additionBasketResult = $this->saveBasketItemArchive($basketItem, $archivedOrderId);
                if ($additionBasketResult->isSuccess())
                {
                    $basketItemIdList[] = $additionBasketResult->getId();
                }
                else
                {
                    $result->addErrors($additionBasketResult->getErrors());
                    break;
                }
            }
        }
 
        if ($result->isSuccess())
        {
            $this->tryUnreserveShipments();
 
            $registry = Sale\Registry::getInstance(Sale\Registry::REGISTRY_TYPE_ORDER);
            $orderClass = $registry->getOrderClassName();
 
            $orderClass::deleteNoDemand($this->getId());
        }
        else
        {
            if (!empty($archivedOrderId))
            {
                Internals\OrderArchiveTable::delete($archivedOrderId);
            }
 
            if (!empty($basketItemIdList) && is_array($basketItemIdList))
            {
                foreach ($basketItemIdList as $archivedBasketItemId)
                {
                    Internals\BasketArchiveTable::delete($archivedBasketItemId);
                }
            }
        }
 
        return $result;
    }
 
    private function callEventOnBeforeOrderArchived(Sale\Order $order)
    {
        $result = new Main\Result();
 
        $eventManager = Main\EventManager::getInstance();
        if ($eventsList = $eventManager->findEventHandlers('sale', Sale\EventActions::EVENT_ON_ORDER_BEFORE_ARCHIVED))
        {
            $event = new Main\Event('sale', Sale\EventActions::EVENT_ON_ORDER_BEFORE_ARCHIVED, array(
                'ENTITY' => $order
            ));
            $event->send();
 
            if ($event->getResults())
            {
                foreach($event->getResults() as $eventResult)
                {
                    if($eventResult->getType() == Main\EventResult::ERROR)
                    {
                        $errorMsg = new Sale\ResultError(Main\Localization\Loc::getMessage('SALE_EVENT_ON_BEFORE_ORDER_SAVED_ERROR'), 'SALE_EVENT_ON_BEFORE_ORDER_SAVED_ERROR');
                        if ($eventResultData = $eventResult->getParameters())
                        {
                            if (isset($eventResultData) && $eventResultData instanceof Sale\ResultError)
                            {
                                $errorMsg = $eventResultData;
                            }
                        }
 
                        $result->addError($errorMsg);
                    }
                }
            }
        }
 
        return $result;
    }
 
    private function tryUnreserveShipments()
    {
        $shipmentData = $this->getOrderDataField('SHIPMENT');
        foreach ($shipmentData as $shipment)
        {
            if ($shipment["RESERVED"] == "Y" && $shipment["DEDUCTED"] == "N")
            {
                if ($shipmentCollection = $this->order->getShipmentCollection())
                {
                    foreach ($shipmentCollection as $shipmentItem)
                    {
                        $shipmentItem->tryUnreserve();
                    }
 
                    $this->order->save();
                }
 
                break;
            }
        }
    }
 
    private function saveOrderArchive()
    {
        $preparedOrderData = array_intersect_key($this->getOrderDataField('ORDER'), array_flip(Manager::getOrderFieldNames()));
        $preparedOrderData['ORDER_ID'] = $this->getId();
        $preparedOrderData['DATE_ARCHIVED'] = new Type\DateTime();
        $preparedOrderData['VERSION'] = Manager::SALE_ARCHIVE_VERSION;
        $preparedFields = $this->prepareEncodeFields($this->orderDataFields);
        $preparedOrderData['ORDER_DATA'] = Main\Web\Json::encode($preparedFields);
        return Internals\OrderArchiveTable::add($preparedOrderData);
    }
 
    private function prepareEncodeFields(array $fields)
    {
        foreach ($fields as &$field)
        {
            if (is_array($field))
            {
                $field = $this->prepareEncodeFields($field);
            }
            elseif ($field instanceof Type\Date)
            {
                \CTimeZone::Disable();
                $field = $field->toString();
                \CTimeZone::Enable();
            }
        }
 
        return $fields;
    }
 
    private function saveBasketItemArchive(array $item, $archivedOrderId)
    {
        $preparedBasketItems = array_intersect_key($item, array_flip(Manager::getBasketFieldNames()));
        $preparedBasketItems['ARCHIVE_ID'] = (int)$archivedOrderId;
        $preparedFields = $this->prepareEncodeFields($item);
        $preparedBasketItems['BASKET_DATA'] = Main\Web\Json::encode($preparedFields);
 
        if (empty($preparedBasketItems['DATE_INSERT']))
        {
            $zeroDate = new \DateTime();
            $zeroDate->setDate(0,0,0);
            $zeroDate->setTime(0,0,0);
            $preparedBasketItems['DATE_INSERT'] = Type\DateTime::createFromPhp($zeroDate);
        }
 
        return Internals\BasketArchiveTable::add($preparedBasketItems);
    }
 
    private function getOrderDataField($name)
    {
        return $this->orderDataFields[$name];
    }
 
}