deliveryservice.php

См. документацию.

<?php
 
namespace Bitrix\Sale\Delivery\Rest;
 
use Bitrix\Main,
    Bitrix\Sale\Delivery,
    Bitrix\Rest\AccessException,
    Bitrix\Rest\RestException;
 
if (!Main\Loader::includeModule('rest'))
{
    return;
}

class DeliveryService extends BaseService
{
    private const ERROR_CHECK_FAILURE = 'ERROR_CHECK_FAILURE';
    private const ERROR_HANDLER_NOT_FOUND = 'ERROR_HANDLER_NOT_FOUND';
    private const ERROR_DELIVERY_ADD = 'ERROR_DELIVERY_ADD';
    private const ERROR_DELIVERY_UPDATE = 'ERROR_DELIVERY_UPDATE';
    private const ERROR_DELIVERY_DELETE = 'ERROR_DELIVERY_DELETE';
    private const ERROR_DELIVERY_CONFIG_UPDATE = 'ERROR_DELIVERY_CONFIG_UPDATE';
    private const ERROR_DELIVERY_NOT_FOUND = 'ERROR_DELIVERY_NOT_FOUND';
 
    private const ALLOWED_DELIVERY_FIELDS = [
        'ID',
        'PARENT_ID',
        'NAME',
        'ACTIVE',
        'DESCRIPTION',
        'SORT',
        'LOGOTIP',
        'CURRENCY',
    ];
 
    private const DELIVERY_FIELDS_STRING_TYPE = [
        'NAME',
        'ACTIVE',
        'DESCRIPTION',
        'CURRENCY',
    ];
 
    private const DELIVERY_FIELDS_INT_TYPE = [
        'ID',
        'PARENT_ID',
        'SORT',
        'LOGOTIP',
    ];

    private static function prepareDeliveryParams(array $data, \CRestServer $server): array
    {
        $data = self::prepareIncomingParams($data);
        $data['APP_ID'] = $server->getClientId();
 
        return $data;
    }

    protected static function getIncomingFieldsMap(): array
    {
        return [
            'LOGOTYPE' => 'LOGOTIP',
        ];
    }

    protected static function getOutcomingFieldsMap(): array
    {
        return [
            'LOGOTIP' => 'LOGOTYPE',
        ];
    }
 
    protected static function castOutcomingFieldsData(array $data): array
    {
        $result = [];
 
        foreach (self::DELIVERY_FIELDS_STRING_TYPE as $stringField)
        {
            if (!array_key_exists($stringField, $data))
            {
                continue;
            }
 
            $result[$stringField] = isset($data[$stringField])
                ? (string)$data[$stringField]
                : null
            ;
        }
 
        foreach (self::DELIVERY_FIELDS_INT_TYPE as $intField)
        {
            if (!array_key_exists($intField, $data))
            {
                continue;
            }
 
            $result[$intField] = isset($data[$intField])
                ? (int)$data[$intField]
                : null
            ;
        }
 
        return $result;
    }

    private static function checkParamsBeforeDeliveryAdd($params): void
    {
        if (empty($params['REST_CODE']))
        {
            throw new RestException('Parameter REST_CODE is not defined', self::ERROR_CHECK_FAILURE);
        }
 
        if (empty($params['NAME']))
        {
            throw new RestException('Parameter NAME is not defined', self::ERROR_CHECK_FAILURE);
        }
 
        if (isset($params['CONFIG']))
        {
            if (!is_array($params['CONFIG']))
            {
                throw new RestException('Parameter CONFIG must be of array type', self::ERROR_CHECK_FAILURE);
            }
 
            self::checkConfig($params['CONFIG']);
        }
 
        if (empty($params['CURRENCY']))
        {
            throw new RestException('Parameter CURRENCY is not defined', self::ERROR_CHECK_FAILURE);
        }
 
        $handlerData = self::getHandlerData($params['REST_CODE']);
        if ($handlerData)
        {
            if ($params['APP_ID'] && !empty($handlerData['APP_ID']) && $handlerData['APP_ID'] !== $params['APP_ID'])
            {
                throw new AccessException();
            }
        }
        else
        {
            throw new RestException(
                'Handler "' . $params['REST_CODE'] . '" not exists', self::ERROR_HANDLER_NOT_FOUND
            );
        }
    }
 
    private static function prepareParamsBeforeDeliveryAdd(array $params): array
    {
        $params['CONFIG'] = self::prepareIncomingConfig($params['CONFIG'] ?? [], $params);
 
        if (isset($params['LOGOTIP']))
        {
            $params['LOGOTIP'] = self::saveFile($params['LOGOTIP']);
        }
 
        return $params;
    }

    private static function checkParamsBeforeDeliveryUpdate($params): void
    {
        if (empty($params['ID']))
        {
            throw new RestException('Parameter ID is not defined', self::ERROR_CHECK_FAILURE);
        }
 
        $data = Delivery\Services\Manager::getById($params['ID']);
        if (!$data)
        {
            throw new RestException('Delivery not found', self::ERROR_DELIVERY_NOT_FOUND);
        }
 
        if (array_key_exists('NAME', $params))
        {
            if (empty($params['NAME']))
            {
                throw new RestException('Parameter NAME should not be empty', self::ERROR_CHECK_FAILURE);
            }
        }
 
        if (!self::hasAccessToDelivery($data, $params['APP_ID']))
        {
            throw new AccessException();
        }
    }

    private static function checkParamsBeforeDeliveryDelete($params): void
    {
        if (empty($params['ID']))
        {
            throw new RestException('Parameter ID is not defined', self::ERROR_CHECK_FAILURE);
        }
 
        $data = Delivery\Services\Manager::getById($params['ID']);
        if (!$data)
        {
            throw new RestException('Delivery not found', self::ERROR_DELIVERY_NOT_FOUND);
        }
 
        if (!self::hasAccessToDelivery($data, $params['APP_ID']))
        {
            throw new AccessException();
        }
    }

    private static function checkParamsBeforeDeliveryConfigGet($params): void
    {
        if (empty($params['ID']))
        {
            throw new RestException('Parameter ID is not defined', self::ERROR_CHECK_FAILURE);
        }
 
        $data = Delivery\Services\Manager::getById($params['ID']);
        if (!$data)
        {
            throw new RestException('Delivery not found', self::ERROR_DELIVERY_NOT_FOUND);
        }
 
        if (!self::hasAccessToDelivery($data, $params['APP_ID']))
        {
            throw new AccessException();
        }
    }
 
    private static function checkParamsBeforeDeliveryConfigUpdate($params): void
    {
        if (empty($params['ID']))
        {
            throw new RestException('Parameter ID is not defined', self::ERROR_CHECK_FAILURE);
        }
 
        if (isset($params['CONFIG']))
        {
            if (!is_array($params['CONFIG']))
            {
                throw new RestException('Parameter CONFIG must be of array type', self::ERROR_CHECK_FAILURE);
            }
 
            self::checkConfig($params['CONFIG']);
        }
 
        $data = Delivery\Services\Manager::getById($params['ID']);
        if (!$data)
        {
            throw new RestException('Delivery not found', self::ERROR_DELIVERY_NOT_FOUND);
        }
 
        if (!self::hasAccessToDelivery($data, $params['APP_ID']))
        {
            throw new AccessException();
        }
    }
 
    private static function saveFile($fileContent)
    {
        $file = \CRestUtil::saveFile($fileContent);
        if ($file)
        {
            $file['MODULE_ID'] = 'sale';
            return \CFile::SaveFile($file, 'sale');
        }
 
        return null;
    }

    public static function addDelivery($query, $n, \CRestServer $server)
    {
        self::checkDeliveryPermission();
        $params = self::prepareDeliveryParams($query, $server);
        self::checkParamsBeforeDeliveryAdd($params);
 
        $params = self::prepareParamsBeforeDeliveryAdd($params);
 
        $fields = [
            'NAME' => $params['NAME'],
            'DESCRIPTION' => $params['DESCRIPTION'] ?? '',
            'CLASS_NAME' => '\\' . \Sale\Handlers\Delivery\RestHandler::class,
            'CURRENCY' => $params['CURRENCY'],
            'SORT' => $params['SORT'] ?? 100,
            'ACTIVE' => $params['ACTIVE'] ?? 'Y',
            'CONFIG' => $params['CONFIG'],
            'LOGOTIP' => $params['LOGOTIP'] ?? null,
        ];
 
        $result = Delivery\Services\Manager::add($fields);
        if ($result->isSuccess())
        {
            $parentDelivery = Delivery\Services\Manager::getList([
                'select' => self::ALLOWED_DELIVERY_FIELDS,
                'filter' => ['=ID' => (int)$result->getId()],
            ])->fetch();
 
            $profiles = [];
            $profilesDeliveryList = Delivery\Services\Manager::getList([
                'select' => self::ALLOWED_DELIVERY_FIELDS,
                'filter' => ['=PARENT_ID' => (int)$result->getId()],
            ]);
            while ($profileDelivery = $profilesDeliveryList->fetch())
            {
                $profiles[] = self::prepareOutcomingFields($profileDelivery);
            }
 
            return [
                'parent' => $parentDelivery ? self::prepareOutcomingFields($parentDelivery) : null,
                'profiles' => $profiles,
            ];
        }
 
        $error = implode("\n", $result->getErrorMessages());
        throw new RestException($error, self::ERROR_DELIVERY_ADD);
    }

    public static function updateDelivery($query, $n, \CRestServer $server): bool
    {
        self::checkDeliveryPermission();
        $params = self::prepareDeliveryParams($query, $server);
        self::checkParamsBeforeDeliveryUpdate($params);
 
        $fields = [];
 
        if (array_key_exists('NAME', $params))
        {
            $fields['NAME'] = (string)$params['NAME'];
        }
 
        if (array_key_exists('ACTIVE', $params))
        {
            $fields['ACTIVE'] = $params['ACTIVE'] === 'Y' ? 'Y' : 'N';
        }
 
        if (array_key_exists('DESCRIPTION', $params))
        {
            $fields['DESCRIPTION'] = (string)$params['DESCRIPTION'];
        }
 
        if (array_key_exists('SORT', $params))
        {
            $fields['SORT'] = (int)$params['SORT'];
        }
 
        if (array_key_exists('CURRENCY', $params))
        {
            $fields['CURRENCY'] = (string)$params['CURRENCY'];
        }
 
        if (array_key_exists('LOGOTIP', $params))
        {
            $fields['LOGOTIP'] = self::saveFile($params['LOGOTIP']);
        }
 
        $result = Delivery\Services\Manager::update($params['ID'], $fields);
        if ($result->isSuccess())
        {
            return true;
        }
 
        $error = implode("\n", $result->getErrorMessages());
        throw new RestException($error, self::ERROR_DELIVERY_UPDATE);
    }

    public static function deleteDelivery($query, $n, \CRestServer $server): bool
    {
        self::checkDeliveryPermission();
        $params = self::prepareDeliveryParams($query, $server);
        self::checkParamsBeforeDeliveryDelete($params);
 
        $result = Delivery\Services\Manager::delete($params['ID']);
        if ($result->isSuccess())
        {
            return true;
        }
 
        $error = implode("\n", $result->getErrorMessages());
        throw new RestException($error, self::ERROR_DELIVERY_DELETE);
    }

    public static function getDeliveryList($query, $n, \CRestServer $server): array
    {
        self::checkDeliveryPermission();
        $params = self::prepareIncomingParams($query);
        self::checkParamsBeforeDeliveryListGet($params);
 
        $select =
            isset($params['SELECT']) && is_array($params['SELECT'])
                ? array_flip(self::prepareIncomingParams(array_flip($params['SELECT'])))
                : self::ALLOWED_DELIVERY_FIELDS
        ;
 
        $filter = isset($params['FILTER']) && is_array($params['FILTER'])
            ? $params['FILTER']
            : []
        ;
 
        $order =
            isset($params['ORDER']) && is_array($params['ORDER'])
                ? self::prepareIncomingParams($params['ORDER'])
                : []
        ;
 
        $result = [];
        $deliveryListResult = Delivery\Services\Manager::getList([
            'select' => $select,
            'filter' => $filter,
            'order' => $order,
        ]);
        while ($delivery = $deliveryListResult->fetch())
        {
            $result[] = self::prepareOutcomingFields($delivery);
        }
 
        return $result;
    }

    private static function checkParamsBeforeDeliveryListGet(array $params)
    {
        $select = isset($params['SELECT']) && is_array($params['SELECT']) ? $params['SELECT'] : [];
        if ($select)
        {
            $select = array_flip(self::prepareIncomingParams(array_flip($select)));
            $diffSelect = array_diff($select, self::ALLOWED_DELIVERY_FIELDS);
 
            if ($diffSelect)
            {
                throw new RestException(
                    implode(', ', $diffSelect) . ' not allowed for select',
                    self::ERROR_CHECK_FAILURE
                );
            }
        }
 
        $filter = isset($params['FILTER']) && is_array($params['FILTER']) ? $params['FILTER'] : [];
        if ($filter)
        {
            $filterFields = [];
            foreach ($filter as $rawName => $value)
            {
                $filterField = \CSqlUtil::GetFilterOperation($rawName);
                if (isset($filterField['FIELD']))
                {
                    $filterFields[] = $filterField['FIELD'];
                }
            }
 
            $filterFields = array_flip(self::prepareIncomingParams(array_flip($filterFields)));
            $diffFilter = array_diff($filterFields, self::ALLOWED_DELIVERY_FIELDS);
            if ($diffFilter)
            {
                throw new RestException(
                    implode(', ', $diffFilter) . ' not allowed for filter',
                    self::ERROR_CHECK_FAILURE
                );
            }
        }
 
        $order =
            isset($params['ORDER']) && is_array($params['ORDER'])
                ? self::prepareIncomingParams($params['ORDER'])
                : []
        ;
        if ($order)
        {
            $diffOrder = array_diff(array_keys($order), self::ALLOWED_DELIVERY_FIELDS);
            if ($diffOrder)
            {
                throw new RestException(
                    implode(', ', $diffOrder) . ' not allowed for order',
                    self::ERROR_CHECK_FAILURE
                );
            }
        }
    }

    public static function getConfig($query, $n, \CRestServer $server): array
    {
        self::checkDeliveryPermission();
        $params = self::prepareDeliveryParams($query, $server);
        self::checkParamsBeforeDeliveryConfigGet($params);
 
        $result = [];
 
        $delivery = Delivery\Services\Manager::getById($params['ID']);
        if ($delivery)
        {
            if (is_array($delivery['CONFIG']))
            {
                $delivery['CONFIG'] = self::prepareOutcomingConfig($delivery['CONFIG']);
            }
 
            $result = is_array($delivery['CONFIG']) ? $delivery['CONFIG'] : [];
        }
 
        return $result;
    }

    public static function updateConfig($query, $n, \CRestServer $server): bool
    {
        self::checkDeliveryPermission();
        $params = self::prepareDeliveryParams($query, $server);
        self::checkParamsBeforeDeliveryConfigUpdate($params);
 
        $data = Delivery\Services\Manager::getById($params['ID']);
        $handlerCode = self::getRestCodeFromConfig($data['CONFIG']);
        $params['REST_CODE'] = $handlerCode;
 
        $result = Delivery\Services\Manager::update(
            $params['ID'],
            [
                'CONFIG' => self::prepareIncomingConfig($params['CONFIG'] ?? [], $params)
            ]
        );
        if ($result->isSuccess())
        {
            return true;
        }
 
        $error = implode("\n", $result->getErrorMessages());
        throw new RestException($error, self::ERROR_DELIVERY_CONFIG_UPDATE);
    }
 
    private static function prepareIncomingConfig(array $config, array $params): array
    {
        $result = [
            'MAIN' => [
                'REST_CODE' => $params['REST_CODE']
            ],
        ];
 
        foreach ($config as $configItem)
        {
            $result['MAIN'][$configItem['CODE']] = $configItem['VALUE'];
        }
 
        return $result;
    }

    private static function prepareOutcomingConfig(array $config): array
    {
        if (isset($config['MAIN']['REST_CODE']))
        {
            unset($config['MAIN']['REST_CODE']);
        }
 
        $configItems = isset($config['MAIN']) && is_array($config['MAIN']) ? $config['MAIN'] : [];
 
        $result = [];
        foreach ($configItems as $configItemCode => $configItemValue)
        {
            $result[] = [
                'CODE' => $configItemCode,
                'VALUE' => $configItemValue,
            ];
        }
 
        return $result;
    }
 
    private static function checkConfig(array $config): void
    {
        $requiredFields = [
            'CODE',
            'VALUE',
        ];
 
        foreach ($config as $configItem)
        {
            foreach ($requiredFields as $requiredField)
            {
                if (
                    !isset($configItem[$requiredField])
                    || $configItem[$requiredField] === ''
                )
                {
                    throw new RestException(
                        'Config item ' . $requiredField . ' is not specified',
                        self::ERROR_CHECK_FAILURE
                    );
                }
            }
        }
    }
}