datamanager.php

<?php
namespace Bitrix\Highloadblock;
 
use Bitrix\Main;
use Bitrix\Main\Entity;
use Bitrix\Main\ORM\Data\UpdateResult;
use Bitrix\Main\ORM\Event;
use Bitrix\Main\ORM\Fields\FieldTypeMask;
use Bitrix\Main\ORM\Objectify\EntityObject;
use Bitrix\Main\ORM\Objectify\Values;
 
abstract class DataManager extends Entity\DataManager
{
    public static function getHighloadBlock()
    {
        return null;
    }
 
    public static function checkFields(Entity\Result $result, $primary, array $data)
    {
        // check for unknown fields
        foreach ($data as $k => $v)
        {
            if (!(static::getEntity()->hasField($k) && static::getEntity()->getField($k) instanceof Entity\ScalarField))
            {
                throw new Main\SystemException(sprintf(
                    'Field `%s` not found in entity when trying to query %s row.',
                    $k, static::getEntity()->getName()
                ));
            }
        }
    }
 
    public static function add(array $data)
    {
        global $USER_FIELD_MANAGER, $APPLICATION;
 
        // prepare entity object for compatibility with new code
        $object = static::convertArrayToObject($data, true);
 
        $result = new Entity\AddResult;
        $hlblock = static::getHighloadBlock();
        $entity = static::getEntity();
 
        try
        {
            static::callOnBeforeAddEvent($object, $data, $result);
 
            // actualize old-style fields array from object
            $data = $object->collectValues(Values::CURRENT, FieldTypeMask::SCALAR);
 
            // check data by uf manager
            if (!$USER_FIELD_MANAGER->checkFields('HLBLOCK_'.$hlblock['ID'], null, $data))
            {
                if(is_object($APPLICATION) && $APPLICATION->getException())
                {
                    $e = $APPLICATION->getException();
                    $result->addError(new Entity\EntityError($e->getString()));
                    $APPLICATION->resetException();
                }
                else
                {
                    $result->addError(new Entity\EntityError("Unknown error while checking userfields"));
                }
            }
 
            // return if any error
            if (!$result->isSuccess(true))
            {
                return $result;
            }
 
            //event on adding
            self::callOnAddEvent($object, $data, []);
 
            // insert base row
            $connection = Main\Application::getConnection();
 
            $tableName = $entity->getDBTableName();
            $identity = $entity->getAutoIncrement();
 
            $id = $connection->add($tableName, [$identity => new Main\DB\SqlExpression('DEFAULT')], $identity);
 
            // format data before save
            $fields = $USER_FIELD_MANAGER->getUserFields('HLBLOCK_'.$hlblock['ID']);
 
            foreach ($fields as $k => $field)
            {
                $fields[$k]['VALUE_ID'] = $id;
            }
 
            list($data, $multiValues) = static::convertValuesBeforeSave($data, $fields);
 
            // data could be changed by uf manager
            foreach ($data as $k => $v)
            {
                $object->set($k, $v);
            }
 
            // use save modifiers
            foreach ($data as $fieldName => $value)
            {
                $field = static::getEntity()->getField($fieldName);
                $data[$fieldName] = $field->modifyValueBeforeSave($value, $data);
            }
 
            if (!empty($data))
            {
                // save data
                $helper = $connection->getSqlHelper();
                $update = $helper->prepareUpdate($tableName, $data);
 
                $sql = "UPDATE ".$helper->quote($tableName)." SET ".$update[0]." WHERE ".$helper->quote($identity)." = ".((int) $id);
                $connection->queryExecute($sql, $update[1]);
            }
 
            // save multi values
            if (!empty($multiValues))
            {
                foreach ($multiValues as $userfieldName => $values)
                {
                    $utmTableName = HighloadBlockTable::getMultipleValueTableName($hlblock, $fields[$userfieldName]);
 
                    foreach ($values as $value)
                    {
                        $connection->add($utmTableName, array('ID' => $id, 'VALUE' => $value));
                    }
                }
            }
 
            // build standard primary
            $primary = null;
 
            if (!empty($id))
            {
                $primary = array($entity->getAutoIncrement() => $id);
                static::normalizePrimary($primary);
            }
            else
            {
                static::normalizePrimary($primary, $data);
            }
 
            // fill result
            $result->setPrimary($primary);
            $result->setData($data);
            $result->setObject($object);
 
            foreach ($primary as $primaryName => $primaryValue)
            {
                $object->sysSetActual($primaryName, $primaryValue);
            }
 
            $entity->cleanCache();
 
            static::callOnAfterAddEvent($object, $data, $id);
        }
        catch (\Exception $e)
        {
            // check result to avoid warning
            $result->isSuccess();
 
            throw $e;
        }
 
        return $result;
    }
 
    public static function update($primary, array $data)
    {
        global $USER_FIELD_MANAGER, $APPLICATION;
 
        // check primary
        static::normalizePrimary(
            $primary, isset($data["fields"]) && is_array($data["fields"]) ? $data["fields"] : $data
        );
        static::validatePrimary($primary);
 
        $object = static::convertArrayToObject($data, false, $primary);
 
        //$oldData = static::getByPrimary($primary)->fetch();
        $object->fill(FieldTypeMask::SCALAR);
        $oldData = $object->collectValues(Values::ACTUAL, FieldTypeMask::SCALAR);
 
        $hlblock = static::getHighloadBlock();
        $entity = static::getEntity();
        $result = new UpdateResult();
 
        try
        {
            static::callOnBeforeUpdateEvent($object, $data, $result);
 
            // actualize old-style fields array from object
            $data = $object->collectValues(Values::CURRENT, FieldTypeMask::SCALAR);
 
            // check data by uf manager CheckFieldsWithOldData
            if (!$USER_FIELD_MANAGER->checkFieldsWithOldData('HLBLOCK_'.$hlblock['ID'], $oldData, $data))
            {
                if(is_object($APPLICATION) && $APPLICATION->getException())
                {
                    $e = $APPLICATION->getException();
                    $result->addError(new Entity\EntityError($e->getString()));
                    $APPLICATION->resetException();
                }
                else
                {
                    $result->addError(new Entity\EntityError("Unknown error while checking userfields"));
                }
            }
 
            // return if any error
            if (!$result->isSuccess(true))
            {
                return $result;
            }
 
            static::callOnUpdateEvent($object, $data, []);
 
            // format data before save
            $fields = $USER_FIELD_MANAGER->getUserFieldsWithReadyData('HLBLOCK_'.$hlblock['ID'], $oldData, LANGUAGE_ID, false, 'ID');
            list($data, $multiValues) = static::convertValuesBeforeSave($data, $fields);
 
            // data could be changed by uf manager
            foreach ($data as $k => $v)
            {
                $object->set($k, $v);
            }
 
            // use save modifiers
            foreach ($data as $fieldName => $value)
            {
                $field = static::getEntity()->getField($fieldName);
                $data[$fieldName] = $field->modifyValueBeforeSave($value, $data);
            }
 
            $connection = Main\Application::getConnection();
 
            if (!empty($data))
            {
                // save data
                $helper = $connection->getSqlHelper();
                $tableName = $entity->getDBTableName();
 
                $update = $helper->prepareUpdate($tableName, $data);
 
                $id = array();
                foreach ($primary as $k => $v)
                {
                    $id[] = $helper->prepareAssignment($tableName, $k, $v);
                }
                $where = implode(' AND ', $id);
 
                $sql = "UPDATE ".$helper->quote($tableName)." SET ".$update[0]." WHERE ".$where;
                $connection->queryExecute($sql, $update[1]);
            }
 
            $result->setAffectedRowsCount($connection);
            $result->setData($data);
            $result->setPrimary($primary);
            $result->setObject($object);
 
            // save multi values
            if (!empty($multiValues))
            {
                foreach ($multiValues as $userfieldName => $values)
                {
                    $utmTableName = HighloadBlockTable::getMultipleValueTableName($hlblock, $fields[$userfieldName]);
 
                    // first, delete old values
                    $connection->query(sprintf(
                        'DELETE FROM %s WHERE %s = %d',
                        $helper->quote($utmTableName), $helper->quote('ID'), $primary['ID']
                    ));
 
                    // insert new values
                    foreach ($values as $value)
                    {
                        $connection->add($utmTableName, array('ID' => $primary['ID'], 'VALUE' => $value));
                    }
                }
            }
 
            $entity->cleanCache();
 
            // event after update
            static::callOnAfterUpdateEvent($object, $data);
        }
        catch (\Exception $e)
        {
            // check result to avoid warning
            $result->isSuccess();
 
            throw $e;
        }
 
        return $result;
    }
 
    public static function delete($primary)
    {
        global $USER_FIELD_MANAGER;
 
        // check primary
        static::normalizePrimary($primary);
        static::validatePrimary($primary);
 
        $entity = static::getEntity();
        $result = new Entity\DeleteResult();
        $hlblock = static::getHighloadBlock();
 
        // get old data
        $oldData = static::getByPrimary($primary)->fetch();
 
        try
        {
            //event before delete
            static::callOnBeforeDeleteEvent($primary, $entity, $result, $oldData);
 
            // return if any error
            if (!$result->isSuccess(true))
            {
                return $result;
            }
 
            //event on delete
            static::callOnDeleteEvent($primary, $entity, $oldData);
 
            // remove row
            $connection = Main\Application::getConnection();
            $helper = $connection->getSqlHelper();
 
            $tableName = $entity->getDBTableName();
 
            $id = array();
            foreach ($primary as $k => $v)
            {
                $id[] = $k." = '".$helper->forSql($v)."'";
            }
            $where = implode(' AND ', $id);
 
            $sql = "DELETE FROM ".$helper->quote($tableName)." WHERE ".$where;
            $connection->queryExecute($sql);
 
            $fields = $USER_FIELD_MANAGER->getUserFields('HLBLOCK_'.$hlblock['ID']);
 
            foreach ($oldData as $k => $v)
            {
                $userfield = $fields[$k];
 
                // remove multi values
                if ($userfield['MULTIPLE'] == 'Y')
                {
                    $utmTableName = HighloadBlockTable::getMultipleValueTableName($hlblock, $userfield);
 
                    $connection->query(sprintf(
                        'DELETE FROM %s WHERE %s = %d',
                        $helper->quote($utmTableName), $helper->quote('ID'), $primary['ID']
                    ));
                }
 
                // remove files
                if ($userfield["USER_TYPE"]["BASE_TYPE"]=="file")
                {
                    if(is_array($oldData[$k]))
                    {
                        foreach($oldData[$k] as $value)
                        {
                            \CFile::delete($value);
                        }
                    }
                    else
                    {
                        \CFile::delete($oldData[$k]);
                    }
                }
            }
 
            $entity->cleanCache();
 
            //event after delete
            static::callOnAfterDeleteEvent($primary, $entity, $oldData);
        }
        catch (\Exception $e)
        {
            // check result to avoid warning
            $result->isSuccess();
 
            throw $e;
        }
 
        return $result;
    }
 
    protected static function callOnBeforeUpdateEvent($object, $fields, $result)
    {
        //event before update
        $event = new Entity\Event($object->entity, self::EVENT_ON_BEFORE_UPDATE, [
            "id" => $object->primary,
            "fields" => $fields,
            'object' => $object
        ]);
 
        $event->send();
        $event->getErrors($result);
        $event->mergeObjectFields($object);
 
        $oldData = $object->collectValues(Values::ACTUAL, FieldTypeMask::SCALAR);
 
        //event before update (modern with namespace)
        $event = new Entity\Event($object->entity, self::EVENT_ON_BEFORE_UPDATE, [
            "id" => $object->primary,
            "primary" => $object->primary,
            "fields" => $fields,
            'object' => $object,
            "oldFields" => $oldData
        ], true);
 
        $event->send();
        $event->getErrors($result);
        $event->mergeObjectFields($object);
    }
 
    protected static function callOnUpdateEvent($object, $fields, $ufdata)
    {
        //event on update
        $event = new Event($object->entity, self::EVENT_ON_UPDATE, [
            "id" => $object->primary,
            "fields" => $fields,
            'object' => clone $object
        ]);
        $event->send();
 
        $oldData = $object->collectValues(Values::ACTUAL, FieldTypeMask::SCALAR);
 
        //event on update (modern with namespace)
        $event = new Event($object->entity, self::EVENT_ON_UPDATE, [
            "id" => $object->primary,
            "primary" => $object->primary,
            "fields" => $fields,
            'object' => clone $object,
            "oldFields" => $oldData
        ], true);
        $event->send();
    }
 
    protected static function callOnAfterUpdateEvent($object, $fields)
    {
        //event after update
        $event = new Entity\Event($object->entity, self::EVENT_ON_AFTER_UPDATE, [
            "id"=> $object->primary,
            "fields" => $fields,
            'object' => clone $object
        ]);
        $event->send();
 
        $oldData = $object->collectValues(Values::ACTUAL, FieldTypeMask::SCALAR);
 
        //event after update (modern with namespace)
        $event = new Entity\Event($object->entity, self::EVENT_ON_AFTER_UPDATE, [
            "id" => $object->primary,
            "primary" => $object->primary,
            "fields" => $fields,
            'object' => clone $object,
            "oldFields" => $oldData
        ], true);
        $event->send();
    }
 
    protected static function callOnBeforeDeleteEvent($primary, $entity, $result, $oldData = null)
    {
        //event before delete
        $event = new Entity\Event($entity, self::EVENT_ON_BEFORE_DELETE, array("id"=>$primary));
        $event->send();
        $event->getErrors($result);
 
        //event before delete (modern with namespace)
        $event = new Entity\Event($entity, self::EVENT_ON_BEFORE_DELETE, array(
            "id"=>$primary, "primary"=>$primary, "oldFields" => $oldData
        ), true);
        $event->send();
        $event->getErrors($result);
    }
 
    protected static function callOnDeleteEvent($primary, $entity, $oldData = null)
    {
        //event on delete
        $event = new Entity\Event($entity, self::EVENT_ON_DELETE, array("id"=>$primary));
        $event->send();
 
        //event on delete (modern with namespace)
        $event = new Entity\Event($entity, self::EVENT_ON_DELETE, array(
            "id"=>$primary, "primary"=>$primary, "oldFields" => $oldData
        ), true);
        $event->send();
    }
 
    protected static function callOnAfterDeleteEvent($primary, $entity, $oldData = null)
    {
        //event after delete
        $event = new Entity\Event($entity, self::EVENT_ON_AFTER_DELETE, array("id"=>$primary));
        $event->send();
 
        //event after delete (modern with namespace)
        $event = new Entity\Event($entity, self::EVENT_ON_AFTER_DELETE, array(
            "id"=>$primary, "primary" => $primary, "oldFields" => $oldData
        ), true);
        $event->send();
    }
 
    protected static function convertValuesBeforeSave($data, $userfields)
    {
        $multiValues = array();
 
        foreach ($data as $k => $v)
        {
            if ($k == 'ID')
            {
                continue;
            }
 
            $userfield = $userfields[$k];
 
            if ($userfield['MULTIPLE'] == 'N')
            {
                $inputValue = array($v);
            }
            else
            {
                $inputValue = $v;
            }
 
            $tmpValue = array();
 
            foreach ($inputValue as $singleValue)
            {
                $tmpValue[] = static::convertSingleValueBeforeSave($singleValue, $userfield);
            }
 
            // write value back
            if ($userfield['MULTIPLE'] == 'N')
            {
                $data[$k] = $tmpValue[0];
            }
            else
            {
                // remove empty (false) values
                $tmpValue = array_filter($tmpValue, array('static', 'isNotNull'));
 
                $data[$k] = $tmpValue;
                $multiValues[$k] = $tmpValue;
            }
        }
 
        return array($data, $multiValues);
    }
 
    protected static function convertSingleValueBeforeSave($value, $userfield)
    {
        if (!isset($userfield['USER_TYPE']) || !is_array($userfield['USER_TYPE']))
        {
            $userfield['USER_TYPE'] = array();
        }
 
        if (
            isset($userfield['USER_TYPE']['CLASS_NAME']) &&
            is_callable(array($userfield['USER_TYPE']['CLASS_NAME'], 'onbeforesave'))
        )
        {
            $value = call_user_func_array(
                array($userfield['USER_TYPE']['CLASS_NAME'], 'onbeforesave'), array($userfield, $value)
            );
        }
 
        if (static::isNotNull($value))
        {
            return $value;
        }
        elseif (
                isset($userfield['USER_TYPE']['BASE_TYPE']) &&
                (
                    $userfield['USER_TYPE']['BASE_TYPE'] == 'int' ||
                    $userfield['USER_TYPE']['BASE_TYPE'] == 'double'
                )
        )
        {
            return null;
        }
        else
        {
            return false;
        }
    }
 
    protected static function isNotNull($value)
    {
        return !($value === null || $value === false || $value === '');
    }
}