%PDF-
%PDF-
Mini Shell
Mini Shell
<?php
/**
* Bitrix Framework
* @package bitrix
* @subpackage sale
* @copyright 2001-2012 Bitrix
*/
namespace Bitrix\Sale;
use Bitrix\Currency;
use Bitrix\Main;
use Bitrix\Main\Type;
use Bitrix\Main\Localization\Loc;
use Bitrix\Sale\Internals;
Loc::loadMessages(__FILE__);
/**
* Class OrderBase
* @package Bitrix\Sale
*/
abstract class OrderBase extends Internals\Entity
{
/** @var Internals\Fields */
protected $calculatedFields = null;
/** @var BasketBase */
protected $basketCollection;
/** @var PropertyValueCollectionBase */
protected $propertyCollection;
/** @var Discount $discount */
protected $discount = null;
/** @var Tax $tax */
protected $tax = null;
/** @var int */
protected $internalId = 0;
/** @var bool $isNew */
protected $isNew = true;
/** @var bool */
protected $isSaveExecuting = false;
/** @var bool $isClone */
protected $isClone = false;
/** @var bool $isOnlyMathAction */
protected $isOnlyMathAction = null;
/** @var bool $isMeaningfulField */
protected $isMeaningfulField = false;
/** @var bool $isStartField */
protected $isStartField = null;
/** @var null $eventClassName */
protected static $eventClassName = null;
/** @var null|string $calculateType */
protected $calculateType = null;
const SALE_ORDER_CALC_TYPE_NEW = 'N';
const SALE_ORDER_CALC_TYPE_CHANGE = 'C';
const SALE_ORDER_CALC_TYPE_REFRESH = 'R';
/**
* OrderBase constructor.
* @param array $fields
* @throws Main\ArgumentNullException
*/
protected function __construct(array $fields = array())
{
$priceRoundedFields = ['PRICE', 'PRICE_DELIVERY', 'SUM_PAID', 'PRICE_PAYMENT', 'DISCOUNT_VALUE'];
foreach ($priceRoundedFields as $code)
{
if (isset($fields[$code]))
{
$fields[$code] = PriceMaths::roundPrecision($fields[$code]);
}
}
parent::__construct($fields);
$this->isNew = (empty($fields['ID']));
}
/**
* Return internal index of order
*
* @return int
*/
public function getInternalId()
{
static $idPool = 0;
if ($this->internalId == 0)
{
$idPool++;
$this->internalId = $idPool;
}
return $this->internalId;
}
/**
* Return field names that can set in \Bitrix\Sale\OrderBase::setField
*
* @return array
*/
public static function getAvailableFields()
{
$result = array(
"LID", "PERSON_TYPE_ID", "CANCELED", "DATE_CANCELED",
"EMP_CANCELED_ID", "REASON_CANCELED", "STATUS_ID", "DATE_STATUS", "EMP_STATUS_ID", "DEDUCTED",
"MARKED", "DATE_MARKED", "EMP_MARKED_ID", "REASON_MARKED",
"PRICE", "CURRENCY", "DISCOUNT_VALUE", "USER_ID",
"DATE_INSERT", "DATE_UPDATE", "USER_DESCRIPTION", "ADDITIONAL_INFO", "COMMENTS", "TAX_VALUE",
"STAT_GID", "RECURRING_ID", "LOCKED_BY", "IS_RECURRING",
"DATE_LOCK", "RECOUNT_FLAG", "AFFILIATE_ID", "DELIVERY_DOC_NUM", "DELIVERY_DOC_DATE", "UPDATED_1C",
"STORE_ID", "ORDER_TOPIC", "RESPONSIBLE_ID", "DATE_BILL", "DATE_PAY_BEFORE", "ACCOUNT_NUMBER",
"XML_ID", "ID_1C", "VERSION_1C", "VERSION", "EXTERNAL_ORDER", "COMPANY_ID",
);
return array_merge($result, static::getCalculatedFields());
}
/**
* Return virtual field names
*
* @return array
*/
public static function getCalculatedFields()
{
return array(
'PRICE_WITHOUT_DISCOUNT',
'ORDER_WEIGHT',
'DISCOUNT_PRICE',
'BASE_PRICE_DELIVERY',
'DELIVERY_LOCATION',
'DELIVERY_LOCATION_ZIP',
'TAX_LOCATION',
'TAX_PRICE',
'VAT_RATE',
'VAT_VALUE',
'VAT_SUM',
'VAT_DELIVERY',
'USE_VAT',
);
}
/**
* @return array
*/
public static function getMeaningfulFields()
{
return array('PERSON_TYPE_ID', 'PRICE');
}
/**
* @param array $fields
* @return mixed
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
private static function createOrderObject(array $fields = array())
{
$registry = Registry::getInstance(static::getRegistryType());
$orderClassName = $registry->getOrderClassName();
return new $orderClassName($fields);
}
/**
* Return registry type of class
*
* @throws Main\NotImplementedException
*/
public static function getRegistryType()
{
throw new Main\NotImplementedException();
}
/**
* Create \Bitrix\Sale\OrderBase object
*
* @param $siteId
* @param null $userId
* @param null $currency
* @return Order
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
* @throws Main\ObjectException
*/
public static function create($siteId, $userId = null, $currency = null)
{
$order = static::createOrderObject();
$order->setFieldNoDemand('LID', $siteId);
if (intval($userId) > 0)
$order->setFieldNoDemand('USER_ID', $userId);
if ($currency == null)
{
$currency = Internals\SiteCurrencyTable::getSiteCurrency($siteId);
}
if ($currency == null)
{
$currency = Currency\CurrencyManager::getBaseCurrency();
}
$order->setFieldNoDemand('CURRENCY', $currency);
$order->setField('STATUS_ID', static::getInitialStatus());
$order->calculateType = static::SALE_ORDER_CALC_TYPE_NEW;
return $order;
}
/**
* Load order object by id
*
* @param $id
* @return null|static
* @throws Main\ArgumentNullException
*/
public static function load($id)
{
if (intval($id) <= 0)
throw new Main\ArgumentNullException("id");
$filter = array(
'filter' => array('ID' => $id),
'select' => array('*'),
);
$list = static::loadByFilter($filter);
if (!empty($list) && is_array($list))
{
return reset($list);
}
return null;
}
/**
* Return object order list satisfying filter
*
* @param array $parameters
* @return array|null
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
public static function loadByFilter(array $parameters)
{
$list = array();
$parameters = static::prepareParams($parameters);
/** @var Main\DB\Result $res */
$res = static::loadFromDb($parameters);
while($orderData = $res->fetch())
{
$order = static::createOrderObject($orderData);
$order->calculateType = static::SALE_ORDER_CALC_TYPE_CHANGE;
$list[] = $order;
}
return (!empty($list) ? $list : null);
}
/**
* @param $parameters
* @return array
*/
private static function prepareParams($parameters)
{
$result = array(
'select' => array('*')
);
if (isset($parameters['filter']))
$result['filter'] = $parameters['filter'];
if (isset($parameters['limit']))
$result['limit'] = $parameters['limit'];
if (isset($parameters['order']))
$result['order'] = $parameters['order'];
if (isset($parameters['offset']))
$result['offset'] = $parameters['offset'];
if (isset($parameters['runtime']))
$result['runtime'] = $parameters['runtime'];
return $result;
}
/**
* Load object order by account number
*
* @param $value
* @return mixed|null
* @throws Main\ArgumentException
* @throws Main\ArgumentNullException
* @throws Main\NotImplementedException
*/
public static function loadByAccountNumber($value)
{
if (strval(trim($value)) == '')
throw new Main\ArgumentNullException("value");
$filter = array(
'filter' => array('=ACCOUNT_NUMBER' => $value),
'select' => array('*'),
);
$list = static::loadByFilter($filter);
if (!empty($list) && is_array($list))
{
return reset($list);
}
return null;
}
/**
* @param array $parameters
* @return Main\DB\Result
* @throws Main\NotImplementedException
*/
static protected function loadFromDb(array $parameters)
{
return static::getList($parameters);
}
/**
* Append basket to order and refresh it
*
* @param BasketBase $basket
* @return Result
* @throws Main\NotSupportedException
*/
public function setBasket(BasketBase $basket)
{
$result = self::appendBasket($basket);
if (!$this->isMathActionOnly())
{
/** @var Result $r */
$r = $basket->refreshData(array('PRICE', 'QUANTITY', 'COUPONS'));
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
}
return $result;
}
/**
* Append basket to order
*
* @param BasketBase $basket
*
* @return Result
* @throws Main\NotSupportedException
*/
public function appendBasket(BasketBase $basket)
{
if ($this->getId())
{
throw new Main\NotSupportedException();
}
$basket->setOrder($this);
$this->basketCollection = $basket;
return new Result();
}
/**
* Return order basket.
*
* @return BasketBase
*/
public function getBasket()
{
if (!isset($this->basketCollection) || empty($this->basketCollection))
$this->basketCollection = $this->loadBasket();
return $this->basketCollection;
}
/**
* Check basket for emptiness
*
* @return bool
*/
public function isNotEmptyBasket()
{
if (!isset($this->basketCollection) || empty($this->basketCollection))
$this->basketCollection = $this->loadBasket();
return !empty($this->basketCollection);
}
/**
* Load basket appended to order
*
* @return BasketBase|null
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
protected function loadBasket()
{
if ((int)$this->getId() > 0)
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var BasketBase $basketClassName */
$basketClassName = $registry->getBasketClassName();
return $basketClassName::loadItemsForOrder($this);
}
return null;
}
/**
* Set value with call events on field modify
*
* @param $name
* @param $value
* @return Result
* @throws Main\ArgumentException
*/
public function setField($name, $value)
{
$priceRoundedFields = array(
'PRICE' => 'PRICE',
'PRICE_DELIVERY' => 'PRICE_DELIVERY',
'SUM_PAID' => 'SUM_PAID',
'PRICE_PAYMENT' => 'PRICE_PAYMENT',
'DISCOUNT_VALUE' => 'DISCOUNT_VALUE',
);
if (isset($priceRoundedFields[$name]))
{
$value = PriceMaths::roundPrecision($value);
}
if ($this->isCalculatedField($name))
{
$this->calculatedFields->set($name, $value);
return new Result();
}
$r = parent::setField($name, $value);
if (!$r->isSuccess())
{
return $r;
}
$fields = $this->fields->getChangedValues();
if (!empty($fields) && !array_key_exists("UPDATED_1C", $fields) && $name != 'UPDATED_1C')
{
parent::setField("UPDATED_1C", "N");
}
return $r;
}
/**
* @internal
*
* Set value without call events on field modify
*
* @param $name
* @param $value
* @throws Main\ArgumentOutOfRangeException
*/
public function setFieldNoDemand($name, $value)
{
$priceRoundedFields = array(
'PRICE' => 'PRICE',
'PRICE_DELIVERY' => 'PRICE_DELIVERY',
'SUM_PAID' => 'SUM_PAID',
'PRICE_PAYMENT' => 'PRICE_PAYMENT',
'DISCOUNT_VALUE' => 'DISCOUNT_VALUE',
);
if (isset($priceRoundedFields[$name]))
{
$value = PriceMaths::roundPrecision($value);
}
if ($this->isCalculatedField($name))
{
$this->calculatedFields->set($name, $value);
return;
}
if (!$this->fields->isChanged("UPDATED_1C") && $name != 'UPDATED_1C')
{
parent::setField("UPDATED_1C", "N");
}
if ($this->isSaveExecuting === false)
{
if ($name === 'ID')
{
$this->isNew = false;
}
}
parent::setFieldNoDemand($name, $value);
}
/**
* Return field value
*
* @param $name
* @return null|string
*/
public function getField($name)
{
if ($this->isCalculatedField($name))
{
return $this->calculatedFields->get($name);
}
return parent::getField($name);
}
/**
* @internal
*
* Init field
*
* @param $name
* @param $value
* @return void
* @throws Main\ArgumentOutOfRangeException
*/
public function initField($name, $value)
{
if ($this->isCalculatedField($name))
{
$this->calculatedFields->set($name, $value);
}
if ($name === 'ID')
{
$this->isNew = false;
}
parent::initField($name, $value);
}
/**
* Return collection of order properties
*
* @return PropertyValueCollectionBase
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
public function getPropertyCollection()
{
if(empty($this->propertyCollection))
{
$this->propertyCollection = $this->loadPropertyCollection();
}
return $this->propertyCollection;
}
/**
* @return PropertyValueCollectionBase
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
* @throws Main\ObjectPropertyException
* @throws Main\SystemException
*/
public function loadPropertyCollection()
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var PropertyValueCollectionBase $propertyCollectionClassName */
$propertyCollectionClassName = $registry->getPropertyValueCollectionClassName();
return $propertyCollectionClassName::load($this);
}
/**
* @internal
*
* @param string $action Action.
* @param PropertyValueBase $property Property.
* @param null|string $name Field name.
* @param null|string|int|float $oldValue Old value.
* @param null|string|int|float $value New value.
* @return Result
*/
public function onPropertyValueCollectionModify($action, PropertyValueBase $property, $name = null, $oldValue = null, $value = null)
{
return new Result();
}
/**
* Full order refresh
*
* @param array $select
* @return Result
* @throws Main\ArgumentException
* @throws Main\ArgumentNullException
* @throws Main\ArgumentOutOfRangeException
* @throws Main\ObjectNotFoundException
*/
public function refreshData($select = array())
{
$result = new Result();
$isStartField = $this->isStartField();
$this->calculateType = ($this->getId() > 0 ? static::SALE_ORDER_CALC_TYPE_REFRESH : static::SALE_ORDER_CALC_TYPE_NEW);
$this->refreshInternal();
if ($isStartField)
{
$hasMeaningfulFields = $this->hasMeaningfulField();
/** @var Result $r */
$r = $this->doFinalAction($hasMeaningfulFields);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
return $result;
}
/**
* @param $select
* @return Result
* @throws Main\ArgumentException
* @throws Main\ArgumentOutOfRangeException
*/
protected function refreshInternal()
{
$result = new Result();
/** @var Basket $basket */
$basket = $this->getBasket();
if (!$basket)
{
return $result;
}
/** @var Result $r */
$r = $this->setField('PRICE', $basket->getPrice());
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
return $result;
}
/**
* Return order id
*
* @return int
*/
public function getId()
{
return (int)$this->getField('ID');
}
/**
* Return person type id of order
*
* @return int
*/
public function getPersonTypeId()
{
return $this->getField('PERSON_TYPE_ID');
}
/**
* Set person type id of order
*
* @param $personTypeId
*
* @return Result
*/
public function setPersonTypeId($personTypeId)
{
return $this->setField('PERSON_TYPE_ID', intval($personTypeId));
}
/**
* Return order price
*
* @return float
*/
public function getPrice()
{
return floatval($this->getField('PRICE'));
}
/**
* Return paid sum
*
* @return float
*/
public function getSumPaid()
{
return floatval($this->getField('SUM_PAID'));
}
/**
* @return float
*/
public function getDeliveryPrice()
{
return floatval($this->getField('PRICE_DELIVERY'));
}
/**
* @return float
*/
public function getDeliveryLocation()
{
return $this->getField('DELIVERY_LOCATION');
}
/**
* @return float
*/
public function getTaxPrice()
{
return floatval($this->getField('TAX_PRICE'));
}
/**
* @return float
*/
public function getTaxValue()
{
return floatval($this->getField('TAX_VALUE'));
}
/**
* @return Result
* @throws Main\ObjectNotFoundException
*/
protected function syncOrderTax()
{
$result = new Result();
/** @var Tax $tax */
if (!$tax = $this->getTax())
{
throw new Main\ObjectNotFoundException('Entity "Tax" not found');
}
$this->resetTax();
/** @var Result $r */
$r = $tax->calculate();
if ($r->isSuccess())
{
$taxResult = $r->getData();
if (isset($taxResult['TAX_PRICE']) && floatval($taxResult['TAX_PRICE']) > 0)
{
/** @var Result $r */
$r = $this->setField('TAX_PRICE', $taxResult['TAX_PRICE']);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
if (isset($taxResult['VAT_SUM']) && floatval($taxResult['VAT_SUM']) > 0)
{
/** @var Result $r */
$r = $this->setField('VAT_SUM', $taxResult['VAT_SUM']);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
if (isset($taxResult['VAT_DELIVERY']) && floatval($taxResult['VAT_DELIVERY']) > 0)
{
/** @var Result $r */
$r = $this->setField('VAT_DELIVERY', $taxResult['VAT_DELIVERY']);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
/** @var Result $r */
$r = $this->setField('TAX_VALUE', $this->isUsedVat()? $this->getVatSum() : $this->getField('TAX_PRICE'));
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
else
{
$result->addErrors($r->getErrors());
}
return $result;
}
/**
* Return discount price
*
* @return float
*/
public function getDiscountPrice()
{
return floatval($this->getField('DISCOUNT_PRICE'));
}
/**
* Return currency
*
* @return string
*/
public function getCurrency()
{
return $this->getField('CURRENCY');
}
/**
* Return user id
*
* @return int
*/
public function getUserId()
{
return $this->getField('USER_ID');
}
/**
* Return site id
*
* @return null|string
*/
public function getSiteId()
{
return $this->getField('LID');
}
/**
* Return TRUE if VAT is used. Else return FALSE
*
* @return bool
*/
public function isUsedVat()
{
$useVat = $this->getField('USE_VAT');
if ($useVat === null)
{
$this->refreshVat();
}
return $this->getField('USE_VAT') === 'Y';
}
/**
* Return order vat rate
*
* @return mixed|null
*/
public function getVatRate()
{
$vatRate = $this->getField('VAT_RATE');
if ($vatRate === null && $this->getId() > 0)
{
$this->refreshVat();
return $this->getField('VAT_RATE');
}
return $vatRate;
}
/**
* Return order vat sum
*
* @return float
*/
public function getVatSum()
{
$vatSum = $this->getField('VAT_SUM');
if ($vatSum === null && $this->getId() > 0)
{
$this->refreshVat();
return $this->getField('VAT_SUM');
}
return $vatSum;
}
/**
* Return TRUE if order has problems. Else return FALSE
* @return null|string
*/
public function isMarked()
{
return ($this->getField('MARKED') == "Y");
}
/**
* Clear VAT info
* @throws Main\ArgumentOutOfRangeException
*/
protected function resetVat()
{
$this->setFieldNoDemand('USE_VAT', 'N');
$this->setFieldNoDemand('VAT_RATE', 0);
$this->setFieldNoDemand('VAT_SUM', 0);
$this->setFieldNoDemand('VAT_DELIVERY', 0);
}
/**
* @internal
*
* Recalculate VAT
*/
public function refreshVat()
{
$this->resetVat();
$vatInfo = $this->calculateVat();
if ($vatInfo && $vatInfo['VAT_RATE'] > 0)
{
return $this->applyCalculatedVat($vatInfo);
}
return new Result();
}
/**
* Calculate VAT
*
* @return array
*/
protected function calculateVat()
{
$result = array();
$basket = $this->getBasket();
if ($basket)
{
$result['VAT_RATE'] = $basket->getVatRate();
$result['VAT_SUM'] = $basket->getVatSum();
}
return $result;
}
/**
* @param array $vatInfo
* @return Result
*/
private function applyCalculatedVat(array $vatInfo)
{
$result = new Result();
/** @var Result $r */
$r = $this->setField('USE_VAT', 'Y');
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
/** @var Result $r */
$r = $this->setField('VAT_RATE', $vatInfo['VAT_RATE']);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
/** @var Result $r */
$r = $this->setField('VAT_SUM', $vatInfo['VAT_SUM']);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
return $result;
}
/**
* Return TRUE if order is deducted. Else return FALSE
*
* @return string
*/
public function isShipped()
{
return $this->getField('DEDUCTED') === 'Y';
}
/**
* Return TRUE if order is external. Else return FALSE
*
* @return bool
*/
public function isExternal()
{
return $this->getField('EXTERNAL_ORDER') == "Y";
}
/**
* @param $field
* @return bool
*/
protected function isCalculatedField($field)
{
if ($this->calculatedFields == null )
{
$this->calculatedFields = new Internals\Fields();
}
return (in_array($field, static::getCalculatedFields()));
}
/**
* @return mixed
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
protected static function getInitialStatus()
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var OrderStatus $orderStatus */
$orderStatus = $registry->getOrderStatusClassName();
return $orderStatus::getInitialStatus();
}
/**
* @return mixed
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
protected static function getFinalStatus()
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var OrderStatus $orderStatus */
$orderStatus = $registry->getOrderStatusClassName();
return $orderStatus::getFinalStatus();
}
/**
* Save order
*
* @return Result
* @throws Main\ArgumentException
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
* @throws Main\ObjectException
*/
public function save()
{
if ($this->isSaveExecuting)
{
trigger_error("Order saving in recursion", E_USER_WARNING);
}
$this->isSaveExecuting = true;
$result = new Result();
$id = $this->getId();
$this->isNew = ($id == 0);
$r = $this->callEventOnBeforeOrderSaved();
if (!$r->isSuccess())
{
$this->isSaveExecuting = false;
return $r;
}
$r = $this->verify();
if (!$r->isSuccess())
{
$this->isSaveExecuting = false;
return $r;
}
$r = $this->onBeforeSave();
if (!$r->isSuccess())
{
$this->isSaveExecuting = false;
return $r;
}
elseif ($r->hasWarnings())
{
$result->addWarnings($r->getWarnings());
}
if ($id > 0)
{
$r = $this->update();
}
else
{
$r = $this->add();
if ($r->getId() > 0)
{
$id = $r->getId();
}
}
if ($r->hasWarnings())
{
$result->addWarnings($r->getWarnings());
}
if (!$r->isSuccess())
{
$this->isSaveExecuting = false;
return $r;
}
if ($id > 0)
{
$result->setId($id);
}
$this->callEventOnSaleOrderEntitySaved();
$r = $this->saveEntities();
if (!$r->isSuccess())
{
$result->addWarnings($r->getErrors());
}
if ($r->hasWarnings())
{
$result->addWarnings($r->getWarnings());
}
/** @var Discount $discount */
$discount = $this->getDiscount();
/** @var Result $r */
$r = $discount->save();
if (!$r->isSuccess())
{
$result->addWarnings($r->getErrors());
}
$r = $this->completeSaving();
if (!$r->isSuccess())
{
$result->addWarnings($r->getErrors());
}
$this->callEventOnSaleOrderSaved();
$this->callDelayedEvents();
$this->onAfterSave();
$this->isNew = false;
$this->isSaveExecuting = false;
$this->clearChanged();
return $result;
}
/**
* @return Result
*/
protected function onAfterSave()
{
return new Result();
}
/**
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
* @return void
*/
protected function callDelayedEvents()
{
$registry = Registry::getInstance(static::getRegistryType());
$notifyClassName = $registry->getNotifyClassName();
$eventList = Internals\EventsPool::getEvents($this->getInternalId());
if ($eventList)
{
foreach ($eventList as $eventName => $eventData)
{
$event = new Main\Event('sale', $eventName, $eventData);
$event->send();
$notifyClassName::callNotify($this, $eventName);
}
Internals\EventsPool::resetEvents($this->getInternalId());
}
$notifyClassName::callNotify($this, EventActions::EVENT_ON_ORDER_SAVED);
}
/**
* @return Result
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
* @throws Main\ObjectException
*/
protected function completeSaving()
{
$result = new Result();
$currentDateTime = new Type\DateTime();
$updateFields = array('RUNNING' => 'N');
$changedFields = $this->fields->getChangedValues();
if ($this->isNew
|| (
$this->isChanged()
&& !array_key_exists('DATE_UPDATE', $changedFields)
)
)
{
$updateFields['DATE_UPDATE'] = $currentDateTime;
}
if ($this->isNew)
{
$updateFields['DATE_INSERT'] = $currentDateTime;
}
$this->setFieldsNoDemand($updateFields);
$r = static::updateInternal($this->getId(), $updateFields);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
return $result;
}
/**
* @return Result
* @throws Main\ArgumentException
* @throws Main\ArgumentNullException
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
* @throws Main\ObjectException
* @throws Main\SystemException
*/
protected function add()
{
global $USER;
$result = new Result();
$currentDateTime = new Type\DateTime();
if (!$this->getField('DATE_INSERT'))
{
$this->setField('DATE_INSERT', $currentDateTime);
}
if (!$this->getField('DATE_UPDATE'))
{
$this->setField('DATE_UPDATE', $currentDateTime);
}
$fields = $this->fields->getValues();
if (is_object($USER) && $USER->isAuthorized())
{
$fields['CREATED_BY'] = $USER->getID();
$this->setFieldNoDemand('CREATED_BY', $fields['CREATED_BY']);
}
if (array_key_exists('REASON_MARKED', $fields) && strlen($fields['REASON_MARKED']) > 255)
{
$fields['REASON_MARKED'] = substr($fields['REASON_MARKED'], 0, 255);
}
$fields['RUNNING'] = 'Y';
$r = $this->addInternal($fields);
if (!$r->isSuccess())
{
return $result->addErrors($r->getErrors());
}
if ($resultData = $r->getData())
{
$result->setData($resultData);
}
$id = $r->getId();
$this->setFieldNoDemand('ID', $id);
$result->setId($id);
$accountNumber = $this->setAccountNumber();
if ($accountNumber)
{
$this->setField('ACCOUNT_NUMBER', $accountNumber);
}
return $result;
}
/**
* @return Result
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
*/
protected function update()
{
$result = new Result();
$fields = $this->fields->getChangedValues();
if ($this->isChanged())
{
if (array_key_exists('DATE_UPDATE', $fields) && $fields['DATE_UPDATE'] === null)
{
unset($fields['DATE_UPDATE']);
}
$fields['VERSION'] = intval($this->getField('VERSION')) + 1;
$this->setFieldNoDemand('VERSION', $fields['VERSION']);
if (array_key_exists('REASON_MARKED', $fields) && strlen($fields['REASON_MARKED']) > 255)
{
$fields['REASON_MARKED'] = substr($fields['REASON_MARKED'], 0, 255);
}
$r = static::updateInternal($this->getId(), $fields);
if (!$r->isSuccess())
{
return $result->addErrors($r->getErrors());
}
if ($resultData = $r->getData())
{
$result->setData($resultData);
}
}
return $result;
}
/**
* @return void
*/
protected function callEventOnSaleOrderEntitySaved()
{
if (self::$eventClassName === null)
{
self::$eventClassName = static::getEntityEventName();
}
if (self::$eventClassName)
{
$oldEntityValues = $this->fields->getOriginalValues();
if (!empty($oldEntityValues))
{
$eventManager = Main\EventManager::getInstance();
if ($eventsList = $eventManager->findEventHandlers('sale', 'On'.self::$eventClassName.'EntitySaved'))
{
/** @var Main\Event $event */
$event = new Main\Event('sale', 'On'.self::$eventClassName.'EntitySaved', array(
'ENTITY' => $this,
'VALUES' => $oldEntityValues,
));
$event->send();
}
}
}
}
/**
* @return void
*/
protected function callEventOnSaleOrderSaved()
{
$eventManager = Main\EventManager::getInstance();
if ($eventsList = $eventManager->findEventHandlers('sale', EventActions::EVENT_ON_ORDER_SAVED))
{
$event = new Main\Event('sale', EventActions::EVENT_ON_ORDER_SAVED, array(
'ENTITY' => $this,
'IS_NEW' => $this->isNew,
'IS_CHANGED' => $this->isChanged(),
'VALUES' => $this->fields->getOriginalValues(),
));
$event->send();
}
}
/**
* @return Result
*/
protected function callEventOnBeforeOrderSaved()
{
$result = new Result();
/** @var array $oldEntityValues */
$oldEntityValues = $this->fields->getOriginalValues();
$eventManager = Main\EventManager::getInstance();
if ($eventsList = $eventManager->findEventHandlers('sale', EventActions::EVENT_ON_ORDER_BEFORE_SAVED))
{
/** @var Main\Entity\Event $event */
$event = new Main\Event('sale', EventActions::EVENT_ON_ORDER_BEFORE_SAVED, array(
'ENTITY' => $this,
'VALUES' => $oldEntityValues
));
$event->send();
if ($event->getResults())
{
/** @var Main\EventResult $eventResult */
foreach($event->getResults() as $eventResult)
{
if($eventResult->getType() == Main\EventResult::ERROR)
{
$errorMsg = new 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 ResultError)
{
/** @var ResultError $errorMsg */
$errorMsg = $eventResultData;
}
}
$result->addError($errorMsg);
}
}
}
}
return $result;
}
/**
* @return Result
*/
protected function saveEntities()
{
$result = new Result();
/** @var BasketBase $basket */
$basket = $this->getBasket();
/** @var Result $r */
$r = $basket->save();
if (!$r->isSuccess())
{
$result->addWarnings($r->getErrors());
}
/** @var Tax $tax */
$tax = $this->getTax();
/** @var Result $r */
$r = $tax->save();
if (!$r->isSuccess())
{
$result->addWarnings($r->getErrors());
}
/** @var PropertyValueCollectionBase $propertyCollection */
$propertyCollection = $this->getPropertyCollection();
/** @var Result $r */
$r = $propertyCollection->save();
if (!$r->isSuccess())
{
$result->addWarnings($r->getErrors());
}
return $result;
}
/**
* Set account number.
*
* @return mixed
* @throws Main\ArgumentNullException
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
* @throws Main\SystemException
*/
protected function setAccountNumber()
{
$accountNumber = Internals\AccountNumberGenerator::generateForOrder($this);
if ($accountNumber !== false)
{
static::updateInternal($this->getId(), ['ACCOUNT_NUMBER' => $accountNumber]);
}
return $accountNumber;
}
/**
* Set VAT sum
*
* @param $price
*/
public function setVatSum($price)
{
$this->setField('VAT_SUM', $price);
}
/**
* Set VAT delivery sum
*
* @param $price
*/
public function setVatDelivery($price)
{
$this->setField('VAT_DELIVERY', $price);
}
/**
* Return date order insert
*
* @return mixed
*/
public function getDateInsert()
{
return $this->getField('DATE_INSERT');
}
/**
* Return value: OrderBase::SALE_ORDER_CALC_TYPE_REFRESH, OrderBase::SALE_ORDER_CALC_TYPE_CHANGE, OrderBase::SALE_ORDER_CALC_TYPE_NEW
*
* @return null|string
*/
public function getCalculateType()
{
return $this->calculateType;
}
/**
* Modify order field.
*
* @param string $name Field name.
* @param mixed|string|int|float $oldValue Old value.
* @param mixed|string|int|float $value New value.
* @return Result
* @throws Main\ArgumentNullException
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
* @throws Main\ObjectNotFoundException
*/
protected function onFieldModify($name, $oldValue, $value)
{
global $USER;
$result = new Result();
if ($name == "PRICE")
{
/** @var Result $r */
$r = $this->refreshVat();
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
}
elseif ($name == "CURRENCY")
{
throw new Main\NotImplementedException('field CURRENCY');
}
elseif ($name == "CANCELED")
{
$event = new Main\Event('sale', EventActions::EVENT_ON_BEFORE_ORDER_CANCELED, array(
'ENTITY' => $this
));
$event->send();
if ($event->getResults())
{
/** @var Main\EventResult $eventResult */
foreach($event->getResults() as $eventResult)
{
if($eventResult->getType() == Main\EventResult::ERROR)
{
$errorMsg = new ResultError(
Main\Localization\Loc::getMessage('SALE_EVENT_ON_BEFORE_ORDER_CANCELED_ERROR'),
'SALE_EVENT_ON_BEFORE_ORDER_CANCELED_ERROR'
);
if ($eventResultData = $eventResult->getParameters())
{
if (isset($eventResultData) && $eventResultData instanceof ResultError)
{
/** @var ResultError $errorMsg */
$errorMsg = $eventResultData;
}
}
$result->addError($errorMsg);
}
}
}
if (!$result->isSuccess())
{
return $result;
}
$r = $this->onOrderModify($name, $oldValue, $value);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
$this->setField('DATE_CANCELED', new Type\DateTime());
if (is_object($USER) && $USER->isAuthorized())
$this->setField('EMP_CANCELED_ID', $USER->getID());
Internals\EventsPool::addEvent(
$this->getInternalId(),
EventActions::EVENT_ON_ORDER_CANCELED,
array('ENTITY' => $this)
);
Internals\EventsPool::addEvent(
$this->getInternalId(),
EventActions::EVENT_ON_ORDER_CANCELED_SEND_MAIL,
array('ENTITY' => $this)
);
}
elseif ($name == "USER_ID")
{
throw new Main\NotImplementedException('field USER_ID');
}
elseif($name == "MARKED")
{
if ($oldValue != "Y")
{
$this->setField('DATE_MARKED', new Type\DateTime());
if ($USER->isAuthorized())
$this->setField('EMP_MARKED_ID', $USER->getID());
}
elseif ($value == "N")
{
$this->setField('REASON_MARKED', '');
}
}
elseif ($name == "STATUS_ID")
{
$event = new Main\Event('sale', EventActions::EVENT_ON_BEFORE_ORDER_STATUS_CHANGE, array(
'ENTITY' => $this,
'VALUE' => $value,
'OLD_VALUE' => $oldValue,
));
$event->send();
if ($event->getResults())
{
/** @var Main\EventResult $eventResult */
foreach($event->getResults() as $eventResult)
{
if($eventResult->getType() == Main\EventResult::ERROR)
{
$errorMsg = new ResultError(
Main\Localization\Loc::getMessage('SALE_EVENT_ON_BEFORE_ORDER_STATUS_CHANGE_ERROR'),
'SALE_EVENT_ON_BEFORE_ORDER_STATUS_CHANGE_ERROR'
);
if ($eventResultData = $eventResult->getParameters())
{
if (isset($eventResultData) && $eventResultData instanceof ResultError)
{
/** @var ResultError $errorMsg */
$errorMsg = $eventResultData;
}
}
$result->addError($errorMsg);
}
}
}
if (!$result->isSuccess())
{
return $result;
}
$this->setField('DATE_STATUS', new Type\DateTime());
if (is_object($USER) && $USER->isAuthorized())
{
$this->setField('EMP_STATUS_ID', $USER->GetID());
}
Internals\EventsPool::addEvent($this->getInternalId(), EventActions::EVENT_ON_ORDER_STATUS_CHANGE, array(
'ENTITY' => $this,
'VALUE' => $value,
'OLD_VALUE' => $oldValue,
));
Internals\EventsPool::addEvent($this->getInternalId(), EventActions::EVENT_ON_ORDER_STATUS_CHANGE_SEND_MAIL, array(
'ENTITY' => $this,
'VALUE' => $value,
'OLD_VALUE' => $oldValue,
));
if ($this->isStatusChangedOnPay($value, $oldValue))
{
Internals\EventsPool::addEvent($this->getInternalId(), EventActions::EVENT_ON_ORDER_STATUS_ALLOW_PAY_CHANGE, array(
'ENTITY' => $this,
'VALUE' => $value,
'OLD_VALUE' => $oldValue,
));
}
}
return $result;
}
/**
* @param $name
* @param $oldValue
* @param $value
* @return Result
*/
protected function onOrderModify($name, $oldValue, $value)
{
return new Result();
}
/**
* Modify basket.
*
* @param string $action Action.
* @param BasketItemBase $basketItem Basket item.
* @param null|string $name Field name.
* @param null|string|int|float $oldValue Old value.
* @param null|string|int|float $value New value.
* @return Result
* @throws Main\NotImplementedException
* @throws Main\NotSupportedException
* @throws Main\ObjectNotFoundException
*/
public function onBasketModify($action, BasketItemBase $basketItem, $name = null, $oldValue = null, $value = null)
{
$result = new Result();
if ($action === EventActions::DELETE)
{
/** @var Result $r */
$r = $this->refreshVat();
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
if ($tax = $this->getTax())
{
$tax->resetTaxList();
}
/** @var Result $result */
$r = $this->refreshOrderPrice();
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
return $result;
}
elseif ($action !== EventActions::UPDATE)
{
return $result;
}
if ($name == "QUANTITY" || $name == "PRICE")
{
/** @var Result $result */
$r = $this->refreshOrderPrice();
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
elseif ($name == "CURRENCY")
{
if ($value != $this->getField("CURRENCY"))
{
throw new Main\NotSupportedException("CURRENCY");
}
}
return $result;
}
/**
* @internal
* @return Result
*/
public function onBeforeBasketRefresh()
{
return new Result();
}
/**
* @internal
* @return Result
*/
public function onAfterBasketRefresh()
{
return new Result();
}
/**
* Get the entity of taxes
*
* @return Tax
*/
public function getTax()
{
if ($this->tax === null)
{
$this->tax = $this->loadTax();
}
return $this->tax;
}
/**
* @internal
*
* Return TRUE if order is new. Else return FALSE
*
* @return null|bool
*/
public function isNew()
{
return $this->isNew;
}
/**
* Reset the value of taxes
*
* @internal
*/
public function resetTax()
{
$this->setFieldNoDemand('TAX_PRICE', 0);
$this->setFieldNoDemand('TAX_VALUE', 0);
}
/**
* Return TRUE if order is changed. Else return FALSE
*
* @return bool
*/
public function isChanged()
{
if (parent::isChanged())
return true;
/** @var PropertyValueCollectionBase $propertyCollection */
if ($propertyCollection = $this->getPropertyCollection())
{
if ($propertyCollection->isChanged())
{
return true;
}
}
/** @var BasketBase $basket */
if ($basket = $this->getBasket())
{
if ($basket->isChanged())
{
return true;
}
}
return false;
}
/**
* @internal
*
* Reset flag of order change
*
* @return void
*/
public function clearChanged()
{
parent::clearChanged();
if ($basket = $this->getBasket())
{
$basket->clearChanged();
}
if ($property = $this->getPropertyCollection())
{
$property->clearChanged();
}
}
/**
* Return TRUE, if this order is cloned. Else return FALSE
*
* @return bool
*/
public function isClone()
{
return $this->isClone;
}
/**
* Return TRUE, if order is payed. Else return FALSE
*
* @return bool
*/
public function isPaid()
{
return $this->getField('PAYED') === "Y";
}
/**
* Return TRUE, if order is allowed delivery. Else return FALSE
*
* @return bool
*/
public function isAllowDelivery()
{
return $this->getField('ALLOW_DELIVERY') === "Y";
}
/**
* Return TRUE, if order is canceled. Else return FALSE
*
* @return bool
*/
public function isCanceled()
{
return $this->getField('CANCELED') === "Y";
}
/**
* Return order hash
*
* @return mixed
*/
public function getHash()
{
/** @var Main\Type\DateTime $dateInsert */
$dateInsert = $this->getDateInsert()->setTimeZone(new \DateTimeZone("Europe/Moscow"));
$timestamp = $dateInsert->getTimestamp();
return md5(
$this->getId().
$timestamp.
$this->getUserId().
$this->getField('ACCOUNT_NUMBER')
);
}
/**
* Verify object to correctness
*
* @return Result
*/
public function verify()
{
$result = new Result();
/** @var BasketBase $basket */
if ($basket = $this->getBasket())
{
$r = $basket->verify();
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
/** @var PropertyValueCollectionBase $propertyCollection */
if ($propertyCollection = $this->getPropertyCollection())
{
$r = $propertyCollection->verify();
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
return $result;
}
/**
* Get order information
*
* @param array $parameters
* @throws Main\NotImplementedException
* @return Main\DB\Result
*/
public static function getList(array $parameters = array())
{
throw new Main\NotImplementedException();
}
/**
* Return tax location
*
* @return null|string
*/
public function getTaxLocation()
{
if (strval(($this->getField('TAX_LOCATION')) == ""))
{
/** @var PropertyValueCollectionBase $propertyCollection */
$propertyCollection = $this->getPropertyCollection();
if ($property = $propertyCollection->getTaxLocation())
{
$this->setField('TAX_LOCATION', $property->getValue());
}
}
return $this->getField('TAX_LOCATION');
}
/**
* Return TRUE if calculations are based on current values. Data from the provider is not requested. Else return false
*
* @return bool
*/
public function isMathActionOnly()
{
return $this->isOnlyMathAction;
}
/**
* @return bool
*/
public function hasMeaningfulField()
{
return $this->isMeaningfulField;
}
/**
* Reset order flags: \Bitrix\Sale\OrderBase::$isStartField, \Bitrix\Sale\OrderBase::$isMeaningfulField
*
* @return void
*/
public function clearStartField()
{
$this->isStartField = null;
$this->isMeaningfulField = false;
}
/**
* @param bool $isMeaningfulField
* @return bool
*/
public function isStartField($isMeaningfulField = false)
{
if ($this->isStartField === null)
{
$this->isStartField = true;
}
else
{
$this->isStartField = false;
}
if ($isMeaningfulField === true)
{
$this->isMeaningfulField = true;
}
return $this->isStartField;
}
/**
* @internal
*
* Set TRUE if calculations should be held on current values. Data from the provider is not requested
*
* @param bool $value
*/
public function setMathActionOnly($value = false)
{
$this->isOnlyMathAction = $value;
}
/**
* @internal
*
* Delete order without demands.
*
* @param $id
* @return Result
* @throws Main\NotImplementedException
*/
public static function deleteNoDemand($id)
{
$result = new Result();
if (!static::isExists($id))
{
$result->addError(new ResultError(Loc::getMessage('SALE_ORDER_ENTITY_NOT_FOUND'), 'SALE_ORDER_ENTITY_NOT_FOUND'));
return $result;
}
/** @var Result $deleteResult */
$deleteResult = static::deleteEntitiesNoDemand($id);
if (!$deleteResult->isSuccess())
{
$result->addErrors($deleteResult->getErrors());
return $result;
}
$r = static::deleteInternal($id);
if (!$r->isSuccess())
$result->addErrors($r->getErrors());
static::deleteExternalEntities($id);
return $result;
}
/**
* Delete order
*
* @param int $id Order id.
* @return Result
* @throws Main\ArgumentNullException
*/
public static function delete($id)
{
$result = new Result();
$registry = Registry::getInstance(static::getRegistryType());
/** @var OrderBase $orderClassName */
$orderClassName = $registry->getOrderClassName();
if (!$order = $orderClassName::load($id))
{
$result->addError(new ResultError(Loc::getMessage('SALE_ORDER_ENTITY_NOT_FOUND'), 'SALE_ORDER_ENTITY_NOT_FOUND'));
return $result;
}
/** @var Notify $notifyClassName */
$notifyClassName = $registry->getNotifyClassName();
$notifyClassName::setNotifyDisable(true);
/** @var Result $r */
$r = $order->setField('CANCELED', 'Y');
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
static::deleteEntities($order);
$event = new Main\Event(
'sale',
EventActions::EVENT_ON_BEFORE_ORDER_DELETE,
array('ENTITY' => $order)
);
$event->send();
foreach ($event->getResults() as $eventResult)
{
$return = null;
if ($eventResult->getType() == Main\EventResult::ERROR)
{
if ($eventResultData = $eventResult->getParameters())
{
if (isset($eventResultData) && $eventResultData instanceof ResultError)
{
/** @var ResultError $errorMsg */
$errorMsg = $eventResultData;
}
}
if (!isset($errorMsg))
$errorMsg = new ResultError('EVENT_ORDER_DELETE_ERROR');
$result->addError($errorMsg);
return $result;
}
}
/** @var Result $r */
$r = $order->save();
if ($r->isSuccess())
{
/** @var Main\Entity\DeleteResult $r */
$r = static::deleteInternal($id);
if ($r->isSuccess())
static::deleteExternalEntities($id);
}
else
{
$result->addErrors($r->getErrors());
}
$notifyClassName::setNotifyDisable(false);
$event = new Main\Event(
'sale',
EventActions::EVENT_ON_ORDER_DELETED,
array('ENTITY' => $order, 'VALUE' => $r->isSuccess())
);
$event->send();
$result->addData(array('ORDER' => $order));
return $result;
}
/**
* @param OrderBase $order
* @return void
*/
protected static function deleteEntities(OrderBase $order)
{
/** @var BasketBase $basketCollection */
if ($basketCollection = $order->getBasket())
{
/** @var BasketItemBase $basketItem */
foreach ($basketCollection as $basketItem)
{
$basketItem->delete();
}
}
/** @var PropertyValueCollectionBase $propertyCollection */
if ($propertyCollection = $order->getPropertyCollection())
{
/** @var PropertyValue $property */
foreach ($propertyCollection as $property)
{
$property->delete();
}
}
}
/**
* @param $id
* @return bool
* @throws Main\NotImplementedException
*/
protected static function isExists($id)
{
$dbRes = static::getList(array('filter' => array('ID' => $id)));
if ($dbRes->fetch())
return true;
return false;
}
/**
* @deprecated Use OrderStatus::isAllowPay instead
*
* @return bool
* @throws Main\ArgumentException
* @throws Main\ArgumentNullException
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
*/
public function isAllowPay()
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var OrderStatus $orderClassName */
$orderClassName = $registry->getOrderStatusClassName();
return $orderClassName::isAllowPay($this->getField('STATUS_ID'));
}
/**
* @param $orderId
*/
protected static function deleteExternalEntities($orderId)
{
return;
}
/**
* @param $oderId
* @return Result
*/
protected static function deleteEntitiesNoDemand($oderId)
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var BasketBase $basketClassName */
$basketClassName = $registry->getBasketClassName();
$r = $basketClassName::deleteNoDemand($oderId);
if (!$r->isSuccess())
return $r;
/** @var PropertyValueCollectionBase $propertyValueCollectionClassName */
$propertyValueCollectionClassName = $registry->getPropertyValueCollectionClassName();
$propertyValueCollectionClassName::deleteNoDemand($oderId);
if (!$r->isSuccess())
return $r;
return new Result();
}
/**
* Return discount object
*
* @return Discount
*/
public function getDiscount()
{
if ($this->discount === null)
{
$this->discount = $this->loadDiscount();
}
return $this->discount;
}
/**
* @return Tax
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
protected function loadTax()
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var Tax $taxClassName */
$taxClassName = $registry->getTaxClassName();
return $taxClassName::load($this);
}
/**
* @return DiscountBase
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
*/
protected function loadDiscount()
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var Discount $discountClassName */
$discountClassName = $registry->getDiscountClassName();
return $discountClassName::buildFromOrder($this);
}
/**
* @return Result
*/
private function refreshOrderPrice()
{
return $this->setField("PRICE", $this->calculatePrice());
}
/**
* @return float
*/
protected function calculatePrice()
{
$basket = $this->getBasket();
$taxPrice = !$this->isUsedVat() ? $this->getField('TAX_PRICE') : 0;
return $basket->getPrice() + $taxPrice;
}
/**
* @return Result
*/
protected function onBeforeSave()
{
return new Result();
}
/**
* @param bool $hasMeaningfulField
* @return Result
* @throws Main\ArgumentNullException
* @throws Main\ObjectNotFoundException
*/
public function doFinalAction($hasMeaningfulField = false)
{
$result = new Result();
$orderInternalId = $this->getInternalId();
$r = Internals\ActionEntity::runActions($orderInternalId);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
if (!$hasMeaningfulField)
{
$this->clearStartField();
return $result;
}
if ($r->hasWarnings())
{
$result->addWarnings($r->getWarnings());
}
$currentIsMathActionOnly = $this->isMathActionOnly();
$basket = $this->getBasket();
if ($basket)
{
$this->setMathActionOnly(true);
if (self::$eventClassName === null)
{
self::$eventClassName = static::getEntityEventName();
}
if (self::$eventClassName)
{
$eventManager = Main\EventManager::getInstance();
$eventsList = $eventManager->findEventHandlers('sale', 'OnBefore'.self::$eventClassName.'FinalAction');
if (!empty($eventsList))
{
$event = new Main\Event('sale', 'OnBefore'.self::$eventClassName.'FinalAction', array(
'ENTITY' => $this,
'HAS_MEANINGFUL_FIELD' => $hasMeaningfulField,
'BASKET' => $basket,
));
$event->send();
if ($event->getResults())
{
/** @var Main\EventResult $eventResult */
foreach($event->getResults() as $eventResult)
{
if($eventResult->getType() == Main\EventResult::ERROR)
{
$errorMsg = new ResultError(
Main\Localization\Loc::getMessage(
'SALE_EVENT_ON_BEFORE_'.strtoupper(self::$eventClassName).'_FINAL_ACTION_ERROR'
),
'SALE_EVENT_ON_BEFORE_'.strtoupper(self::$eventClassName).'_FINAL_ACTION_ERROR'
);
$eventResultData = $eventResult->getParameters();
if ($eventResultData)
{
if (isset($eventResultData) && $eventResultData instanceof ResultError)
{
/** @var ResultError $errorMsg */
$errorMsg = $eventResultData;
}
}
$result->addError($errorMsg);
}
}
}
}
if (!$result->isSuccess())
{
return $result;
}
}
// discount
$discount = $this->getDiscount();
$r = $discount->calculate();
if (!$r->isSuccess())
{
// $this->clearStartField();
// $result->addErrors($r->getErrors());
// return $result;
}
if ($r->isSuccess() && ($discountData = $r->getData()) && !empty($discountData) && is_array($discountData))
{
/** @var Result $r */
$r = $this->applyDiscount($discountData);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
}
/** @var Tax $tax */
$tax = $this->getTax();
/** @var Result $r */
$r = $tax->refreshData();
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
return $result;
}
$taxResult = $r->getData();
$taxChanged = false;
if (isset($taxResult['TAX_PRICE']) && floatval($taxResult['TAX_PRICE']) >= 0)
{
if (!$this->isUsedVat())
{
$taxChanged = $this->getField('TAX_PRICE') !== $taxResult['TAX_PRICE'];
if ($taxChanged)
{
$this->setField('TAX_PRICE', $taxResult['TAX_PRICE']);
$this->refreshOrderPrice();
}
}
}
if (array_key_exists('VAT_SUM', $taxResult))
{
if ($this->isUsedVat())
{
$this->setField('VAT_SUM', $taxResult['VAT_SUM']);
}
}
if ($taxChanged || $this->isUsedVat())
{
$taxValue = $this->isUsedVat()? $this->getVatSum() : $this->getField('TAX_PRICE');
if (floatval($taxValue) != floatval($this->getField('TAX_VALUE')))
{
$this->setField('TAX_VALUE', floatval($taxValue));
}
}
}
if (!$currentIsMathActionOnly)
$this->setMathActionOnly(false);
$this->clearStartField();
if (self::$eventClassName)
{
$eventManager = Main\EventManager::getInstance();
if ($eventsList = $eventManager->findEventHandlers('sale', 'OnAfter'.self::$eventClassName.'FinalAction'))
{
$event = new Main\Event(
'sale',
'OnAfter'.self::$eventClassName.'FinalAction',
array('ENTITY' => $this)
);
$event->send();
}
}
return $result;
}
/**
* Apply the result of the discounts to the order.
*
* @internal
*
* @param array $data
* @return Result
* @throws Main\ArgumentNullException
*/
public function applyDiscount(array $data)
{
if (!empty($data['BASKET_ITEMS']) && is_array($data['BASKET_ITEMS']))
{
/** @var BasketBase $basket */
$basket = $this->getBasket();
$basketResult = $basket->applyDiscount($data['BASKET_ITEMS']);
if (!$basketResult->isSuccess())
return $basketResult;
unset($basketResult, $basket);
$this->refreshOrderPrice();
}
return new Result();
}
/**
* @param $value
* @return Result
* @throws Main\ArgumentException
*/
protected function setReasonMarked($value)
{
$result = new Result();
if (!empty($value))
{
$orderReasonMarked = $this->getField('REASON_MARKED');
if (is_array($value))
{
$newOrderReasonMarked = '';
foreach ($value as $err)
{
$newOrderReasonMarked .= (strval($newOrderReasonMarked) != '' ? "\n" : "") . $err;
}
}
else
{
$newOrderReasonMarked = $value;
}
/** @var Result $r */
$r = $this->setField('REASON_MARKED', $orderReasonMarked. (strval($orderReasonMarked) != '' ? "\n" : ""). $newOrderReasonMarked);
if (!$r->isSuccess())
{
$result->addErrors($r->getErrors());
}
}
return $result;
}
/**
* Reset the value of the order and delivery
*
* @internal
*
* @param array $select
* @throws Main\ArgumentOutOfRangeException
*/
public function resetData($select = array('PRICE'))
{
if (in_array('PRICE', $select))
{
$this->setFieldNoDemand('PRICE', 0);
}
if (in_array('PRICE_DELIVERY', $select))
{
$this->setFieldNoDemand('PRICE_DELIVERY', 0);
}
}
/**
* @param $value
* @param $oldValue
* @return bool
* @throws Main\ArgumentException
* @throws Main\ArgumentNullException
* @throws Main\ArgumentOutOfRangeException
* @throws Main\NotImplementedException
*/
protected function isStatusChangedOnPay($value, $oldValue)
{
$registry = Registry::getInstance(static::getRegistryType());
/** @var OrderStatus $orderStatus */
$orderStatus = $registry->getOrderStatusClassName();
$allowPayStatus = $orderStatus::getAllowPayStatusList();
$disallowPayStatus = $orderStatus::getDisallowPayStatusList();
return !empty($disallowPayStatus)
&& in_array($oldValue, $disallowPayStatus)
&& !empty($allowPayStatus)
&& in_array($value, $allowPayStatus);
}
/**
* Create order clone
*
* @return OrderBase
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
* @throws Main\SystemException
*/
public function createClone()
{
$cloneEntity = new \SplObjectStorage();
/** @var OrderBase $orderClone */
$orderClone = clone $this;
$orderClone->isClone = true;
/** @var Internals\Fields $fields */
if ($fields = $this->fields)
{
$orderClone->fields = $fields->createClone($cloneEntity);
}
/** @var Internals\Fields $calculatedFields */
if ($calculatedFields = $this->calculatedFields)
{
$orderClone->calculatedFields = $calculatedFields->createClone($cloneEntity);
}
if (!$cloneEntity->contains($this))
{
$cloneEntity[$this] = $orderClone;
}
$this->cloneEntities($cloneEntity);
return $orderClone;
}
/**
* @param \SplObjectStorage $cloneEntity
* @throws Main\ArgumentException
* @throws Main\NotImplementedException
* @throws Main\SystemException
*/
protected function cloneEntities(\SplObjectStorage $cloneEntity)
{
if (!$cloneEntity->contains($this))
{
throw new Main\SystemException();
}
$orderClone = $cloneEntity[$this];
/** @var BasketBase $basket */
if ($basket = $this->getBasket())
{
$orderClone->basketCollection = $basket->createClone($cloneEntity);
}
/** @var PropertyValueCollectionBase $propertyCollection */
if ($propertyCollection = $this->getPropertyCollection())
{
$orderClone->propertyCollection = $propertyCollection->createClone($cloneEntity);
}
if ($tax = $this->getTax())
{
$orderClone->tax = $tax->createClone($cloneEntity);
}
if ($discount = $this->getDiscount())
{
$orderClone->discount = $discount->createClone($cloneEntity);
}
}
/**
* @param array $data
* @throws Main\NotImplementedException
* @return Main\Entity\AddResult
*/
abstract protected function addInternal(array $data);
/**
* @param $primary
* @param array $data
* @throws Main\NotImplementedException
* @return Main\Entity\UpdateResult
*/
protected static function updateInternal($primary, array $data)
{
throw new Main\NotImplementedException();
}
/**
* @param $primary
* @throws Main\NotImplementedException
* @return Main\Entity\DeleteResult
*/
protected static function deleteInternal($primary)
{
throw new Main\NotImplementedException();
}
/**
* Return user field id
*
* @return null
*/
public static function getUfId()
{
return null;
}
/**
* @deprecated Use \Bitrix\Sale\OrderBase::getAvailableFields instead
*
* @return array
*/
public static function getSettableFields()
{
return static::getAvailableFields();
}
}
Zerion Mini Shell 1.0