base.php

<?php
namespace Bitrix\Sender\Entity;
 
use Bitrix\Main\Entity\Base as MainEntityBase;
use Bitrix\Main\Entity\DataManager as MainDataManager;
use Bitrix\Main\Error;
use Bitrix\Main\ErrorCollection;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\SystemException;
use Bitrix\Sender\Search;
use Bitrix\Sender\Security;
 
Loc::loadMessages(__FILE__);
 
abstract class Base
{
    const SEARCH_FIELD_NAME = 'SEARCH_CONTENT';
 
    protected $errors;
 
    protected $id;
 
    protected $data = array();
 
    protected $user;
 
    protected $searchBuilder;
 
    public static function create($id = null)
    {
        return new static($id);
    }
 
    public function __construct($id = null)
    {
        $this->errors = new ErrorCollection();
        $this->setData($this->getDefaultData());
 
        if ($id)
        {
            $this->load($id);
        }
    }
 
    protected function getDefaultData()
    {
        return array();
    }
 
 
    protected function filterDataByEntityFields(MainEntityBase $entity, array &$data)
    {
        foreach ($data as $key => $value)
        {
            if (!$entity->hasField($key))
            {
                unset($data[$key]);
            }
        }
    }
 
 
    protected function filterDataByChanging(array &$data, array $previousData)
    {
        foreach ($data as $key => $value)
        {
            if (!isset($previousData[$key]))
            {
                continue;
            }
 
            if ($previousData[$key] !== $data[$key])
            {
                continue;
            }
 
            unset($data[$key]);
        }
 
        return count($data) > 0;
    }
 
    protected function saveByEntity(MainEntityBase $entity, $id, array $data, $primary = null)
    {
        $className = $entity->getDataClass();
 
        $primary = $primary ?: $id;
 
        if($id)
        {
            if (array_key_exists('ID', $data))
            {
                unset($data['ID']);
            }
            $resultDb = $className::update($primary, $data);
        }
        else
        {
            $resultDb = $className::add($data);
            $id = $resultDb->getId();
        }
 
        if(!$resultDb->isSuccess())
        {
            $this->errors->add($resultDb->getErrors());
        }
 
        return $id;
    }
 
    protected function removeByEntity(MainEntityBase $entity, $primary)
    {
        $className = $entity->getDataClass();
        $result = $className::delete($primary);
 
        if(!$result->isSuccess())
        {
            $this->errors->add($result->getErrors());
        }
 
        return !$this->hasErrors();
    }
 
    abstract protected function loadData($id);
 
    abstract protected function saveData($id, array $data);
 
    protected function copyData($id, array $data = array())
    {
        $loadedData = $this->loadData($id);
        if (!$loadedData)
        {
            return false;
        }
        unset($loadedData['ID']);
        $data = $data + $loadedData;
 
        if (isset($data['FIELDS']))
        {
            foreach ($data['FIELDS'] as $index => $field)
            {
                if ($field['TYPE'] !== 'file')
                {
                    continue;
                }
 
                if (empty($field['VALUE']))
                {
                    continue;
                }
 
                $values = is_array($field['VALUE']) ? $field['VALUE'] : explode(',', $field['VALUE']);
                $field['VALUE'] = array();
                foreach ($values as $fileId)
                {
                    $copiedFileId = \CFile::copyFile($fileId);
                    if (!$copiedFileId)
                    {
                        continue;
                    }
 
                    $field['VALUE'][] = $copiedFileId;
                }
                $field['VALUE'] = implode(',', $field['VALUE']);
                $data['FIELDS'][$index] = $field;
            }
        }
 
        return $this->saveData(null, $data);
    }
 
    public function loadByArray(array $data)
    {
        $this->clearErrors();
        $this->setId((isset($data['ID']) && $data['ID']) ? $data['ID'] : null);
        $this->setData($this->getDefaultData())->mergeData($data);
 
        return !$this->hasErrors();
    }
 
    public function load($id)
    {
        $this->clearErrors();
        $this->setData($this->getDefaultData());
 
        if (!$id)
        {
            return false;
        }
 
        $data = $this->loadData($id);
        if (!is_array($data))
        {
            $data = array();
        }
        $this->mergeData($data);
 
        if (!$this->hasErrors())
        {
            $this->id = $id;
        }
 
        return !$this->hasErrors();
    }
 
    public function save()
    {
        $this->clearErrors();
 
        $id = $this->saveData($this->getId(), $this->getData());
        if ($id)
        {
            $this->setId($id);
        }
 
        if (!$this->hasErrors())
        {
            $this->saveSearchIndex();
        }
 
        return !$this->hasErrors();
    }
 
    public function getId()
    {
        return $this->id;
    }
 
    public function setId($id)
    {
        if ($id)
        {
            $this->id = $id;
        }
 
        return $this;
    }
 
    public function set($key, $value)
    {
        $this->data[$key] = $value;
        return $this;
    }
 
    public function unsetByKey($key)
    {
        unset($this->data[$key]);
        return $this;
    }
 
    public function get($key, $defaultValue = null)
    {
        return (isset($this->data[$key]) ? $this->data[$key] : $defaultValue);
    }
 
    public function mergeData(array $data)
    {
        $this->setData($data + $this->getData());
        return $this;
    }
 
    public function setData(array $data)
    {
        $this->data = $data;
        return $this;
    }
 
    public function getData()
    {
        return $this->data;
    }
 
    public function hasErrors()
    {
        return !$this->errors->isEmpty();
    }
 
    public function clearErrors()
    {
        $this->errors->clear();
    }
 
    public function addError($message, $code = null)
    {
        $this->errors->setError(new Error($message, $code));
    }
 
    public function getErrorCollection()
    {
        return $this->errors;
    }
 
    public function getErrors()
    {
        return $this->errors->toArray();
    }
 
    public function getErrorMessages()
    {
        $list = array();
        foreach ($this->errors as $error)
        {
            $list[] = $error->getMessage();
        }
 
        return $list;
    }
 
    public function setUser(Security\User $user = null)
    {
        $this->user = $user;
        return $this;
    }
 
    public function getUser()
    {
        if (!$this->user)
        {
            $this->user = Security\User::current();
        }
 
        return $this->user;
    }
 
    public static function getDataClass()
    {
        return null;
    }
 
    public static function getSearchBuilder()
    {
        static $builder = null;
        if ($builder === null && static::getDataClass())
        {
            $dataClass = static::getDataClass();
            $builder = new Search\Builder(
                $dataClass::getEntity(),
                static::SEARCH_FIELD_NAME
            );
        }
 
        return $builder;
    }
 
 
 
    protected function prepareSearchContent()
    {
        return $this;
    }
 
    public function saveSearchIndex()
    {
        if (!$this->getId())
        {
            return false;
        }
 
        if (!$this->getSearchBuilder())
        {
            return false;
        }
 
        if (!$this->getSearchBuilder()->hasField())
        {
            return false;
        }
 
        $this->getSearchBuilder()->getContent()->clear();
        $this->prepareSearchContent();
        return $this->getSearchBuilder()->save($this->getId());
    }
}