importbase.php

<?php
namespace Bitrix\Sale\Exchange;
 
use Bitrix\Main;
use Bitrix\Sale;
use Bitrix\Sale\Exchange;
 
abstract class ImportBase
{
    const ITEM_ITEM = 'ITEM';
    const ITEM_SERVICE = 'SERVICE';
 
    protected $collisionErrors = false;
    protected $collisionWarnings = false;
    protected $logging = false;
 
    protected $fields;
    protected $settings = null;
 
    protected $loadCriterion = null;
    protected $loadLogger = null;
    protected $loadCollision = null;
 
    protected $logger = array();
 
    static public function getFieldExternalId()
    {
        throw new Main\NotImplementedException('The method is not implemented.');
    }
 
    abstract public function getEntity();
 
    abstract public function getOwnerTypeId();
 
    abstract public function add(array $params);
 
    abstract public function update(array $params);
 
    abstract public function delete(array $params = null);
 
    abstract protected function checkFields(array $fields);
 
    abstract public function load(array $fields);
 
    public function import(array $params)
    {
        $result = new Sale\Result();
        if($this->getId()>0)
        {
            $result = $this->update($params);
        }
        elseif($this->isImportable())
        {
            $result = $this->add($params);
        }
 
        $this->initLogger();
 
        return $result;
    }
 
    abstract public function getId();
 
    public function getExternalId()
    {
        $entity = $this->getEntity();
        if(!empty($entity))
        {
            return $entity->getField(static::getFieldExternalId());
        }
 
        return null;
    }
 
    abstract public function isImportable();
 
    public function setFields(array $values)
    {
        foreach ($values as $key=>$value)
        {
            $this->setField($key, $value);
        }
    }
 
    public function setField($name, $value)
    {
        $this->fields->set($name, $value);
    }
 
    public function getField($name)
    {
        return $this->fields->get($name);
    }
 
    public function getFieldValues()
    {
        return $this->fields->getValues();
    }
 
    abstract public function refreshData(array $fields);
 
    protected function getFieldsTraits()
    {
        $entity = $this->getEntity();
        return $entity->getFieldValues();
    }
 
    abstract public function initFields();
 
    public function initFieldsFromArray($fields)
    {
        $this->setFields($fields);
    }
 
    public function loadSettings(ISettings $settings)
    {
        $this->settings = $settings;
    }
 
    public function loadCriterion(ICriterion $criterion)
    {
        $this->loadCriterion = $criterion;
    }
 
    public function getLoadedCriterion()
    {
        return $this->loadCriterion;
    }
 
    public function getCurrentCriterion($entity)
    {
        $criterions = $this->getLoadedCriterion();
        return $criterions::getCurrent($this->getOwnerTypeId(), $entity);
    }
 
    public function loadCollision(ICollision $collision)
    {
        $this->loadCollision = $collision;
    }
 
    public function getLoadedCollision()
    {
        return $this->loadCollision;
    }
 
    public function getSettings()
    {
        return $this->settings;
    }
 
    public function getCurrentCollision($typeId)
    {
        $collision = $this->getLoadedCollision();
        return $collision::getCurrent($typeId);
    }
 
    public function loadLogger(Exchange\Internals\Logger $logger)
    {
        $this->loadLogger = $logger;
    }
 
    public function getLoadedLogger()
    {
        return $this->loadLogger;
    }
 
    public function getCurrentLogger()
    {
        $logger = $this->getLoadedLogger();
        return $logger::getCurrent();
    }
 
    public function initLogger()
    {
        $this->logging = true;
 
        $logger = $this->getCurrentLogger();
        $this->logger = $logger;
    }
 
    public function getLogger()
    {
        return $this->logger;
    }
 
    public function hasCollisionErrors()
    {
        return $this->collisionErrors;
    }
 
    public function hasCollisionWarnings()
    {
        return $this->collisionWarnings;
    }
 
    public function hasLogging()
    {
        return $this->logging;
    }
 
    static private function getSaleExport()
    {
        static $exportProfiles = null;
 
        if($exportProfiles === null)
        {
            $exportProfiles = \CSaleExport::getSaleExport();
        }
        return $exportProfiles;
 
    }
 
    static public function getBusinessValue(\Bitrix\Sale\IBusinessValueProvider $entity)
    {
        $order = static::getBusinessValueOrderProvider($entity);
 
        $orderFields = $order->getFieldValues();
        $paymentList = array();
        $shipmentList = array();
 
        if($paymentCollection = $order->getPaymentCollection())
        {
            foreach ($paymentCollection as $payment)
            {
                $paymentList[$payment->getId()] = $payment->getPaymentSystemName();
            }
        }
        if($shipmentCollection = $order->getShipmentCollection())
        {
            foreach ($shipmentCollection as $shipment)
            {
                $shipmentList[$shipment->getId()] = $shipment->getDeliveryName();
            }
        }
 
        $arProp = \CSaleExport::prepareSaleProperty(
            $orderFields,
            false,
            false,
            $paymentList,
            $shipmentList,
            $locationStreetPropertyValue,
            $order
        );
 
        $exportProfiles = static::getSaleExport();
        $exportProfile = (array_key_exists($order->getPersonTypeId(), $exportProfiles) ? $exportProfiles[$order->getPersonTypeId()]: array());
 
        $properties = \CSaleExport::prepareSalePropertyRekv(
            $entity,
            $exportProfile,
            $arProp,
            $locationStreetPropertyValue
        );
        $properties['REKV'] = static::modifyRekv($properties['REKV'], $exportProfile);
 
        return $properties;
    }
 
    static private function modifyRekv($rekv, array $exportProfile)
    {
        $result = array();
        foreach ($rekv as $k=>$v)
        {
            if(isset($exportProfile[$k]) && $exportProfile[$k]['NAME'] <> '' && $v <> '')
            {
                $result[$exportProfile[$k]['NAME']] = $v;
            }
        }
        return $result;
    }
 
    static protected function getBusinessValueOrderProvider(\Bitrix\Sale\IBusinessValueProvider $entity)
    {
        throw new Main\NotImplementedException('The method is not implemented.');
    }
}