event.php

<?php
namespace Bitrix\Main\ORM;
 
use Bitrix\Main\ORM\Data\DataManager;
use Bitrix\Main\ORM\Data\Result;
use Bitrix\Main\ORM\Objectify\EntityObject;
 
class Event extends \Bitrix\Main\Event
{
    protected $entity;
    protected $entityEventType;
 
    public function __construct(Entity $entity, $type, array $parameters = array(), $withNamespace = false)
    {
        if ($withNamespace)
        {
            $eventName = $entity->getNamespace() . $entity->getName() . '::' . $type;
            $this->entityEventType = $type;
        }
        else
        {
            $eventName = $entity->getName().$type;
        }
 
        parent::__construct($entity->getModule(), $eventName, $parameters);
 
        $this->entity = $entity;
    }
 
    public function getEntity()
    {
        return $this->entity;
    }
 
    public function getErrors(Result $result)
    {
        $hasErrors = false;
 
        foreach($this->getResults() as $evenResult)
        {
            if($evenResult->getType() === EventResult::ERROR)
            {
                $hasErrors = true;
                $result->addErrors($evenResult->getErrors());
            }
        }
        return $hasErrors;
    }
 
    public function mergeFields(array $data)
    {
        if ($this->getResults() != null)
        {
            foreach($this->getResults() as $evenResult)
            {
                $removed = $evenResult->getUnset();
                foreach($removed as $val)
                {
                    unset($data[$val]);
                }
 
                $modified = $evenResult->getModified();
                if(!empty($modified))
                {
                    $data = array_merge($data, $modified);
                }
            }
        }
        return $data;
    }
 
    public function mergeObjectFields(EntityObject $object)
    {
        if ($this->getResults() != null)
        {
            foreach($this->getResults() as $evenResult)
            {
                $removed = $evenResult->getUnset();
                foreach($removed as $fieldName)
                {
                    // sometimes data array can be used for storing non-entity data
                    if ($object->entity->hasField($fieldName))
                    {
                        $object->unset($fieldName);
                    }
                }
 
                $modified = $evenResult->getModified();
                if(!empty($modified))
                {
                    foreach ($modified as $fieldName => $value)
                    {
                        $object->set($fieldName, $value);
                    }
                }
            }
        }
    }
 
    public function send($sender = null)
    {
        static $events = array(
            DataManager::EVENT_ON_BEFORE_ADD => true,
            DataManager::EVENT_ON_ADD => true,
            DataManager::EVENT_ON_AFTER_ADD => true,
            DataManager::EVENT_ON_BEFORE_UPDATE => true,
            DataManager::EVENT_ON_UPDATE => true,
            DataManager::EVENT_ON_AFTER_UPDATE => true,
            DataManager::EVENT_ON_BEFORE_DELETE => true,
            DataManager::EVENT_ON_DELETE => true,
            DataManager::EVENT_ON_AFTER_DELETE => true,
        );
 
        if(isset($events[$this->entityEventType]))
        {
            //The event handler function name magically equals to the event type (e.g. "OnBeforeAdd").
            //There are emtpy handlers in the DataManager class.
            $result = call_user_func_array(array($this->entity->getDataClass(), $this->entityEventType), array($this));
            if (($result !== null) && !($result instanceof EventResult))
            {
                $result = new EventResult();
            }
            if($result !== null)
            {
                $this->addResult($result);
            }
        }
 
        parent::send($sender);
    }
}