requestservice.php

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

<?php
 
namespace Bitrix\Sale\Delivery\Rest;
 
use Bitrix\Main;
use Bitrix\Sale\Delivery\Requests;
use Bitrix\Sale\Delivery;
use Bitrix\Rest\RestException;
 
if (!Main\Loader::includeModule('rest'))
{
    return;
}
 
class RequestService extends BaseService
{
    private const ERROR_CODE_ADDRESSEE_IS_NOT_SPECIFIED = 'ADDRESSEE_IS_NOT_SPECIFIED';
    private const ERROR_CODE_ADDRESSEE_UNEXPECTED_VALUE = 'ADDRESSEE_UNEXPECTED_VALUE';
    private const ERROR_CODE_MESSAGE_NOT_SPECIFIED = 'MESSAGE_NOT_SPECIFIED';
    private const ERROR_CODE_MESSAGE_STATUS_NOT_SPECIFIED = 'MESSAGE_STATUS_NOT_SPECIFIED';
    private const ERROR_CODE_MESSAGE_STATUS_SEMANTIC_NOT_SPECIFIED = 'MESSAGE_STATUS_SEMANTIC_NOT_SPECIFIED';
    private const ERROR_CODE_UNEXPECTED_MESSAGE_STATUS_SEMANTIC = 'UNEXPECTED_MESSAGE_STATUS_SEMANTIC';
    private const ERROR_CODE_DELIVERY_ID_NOT_SPECIFIED = 'DELIVERY_ID_NOT_SPECIFIED';
    private const ERROR_CODE_DELIVERY_NOT_FOUND = 'DELIVERY_NOT_FOUND';
    private const ERROR_CODE_REQUEST_ID_NOT_SPECIFIED = 'REQUEST_ID_NOT_SPECIFIED';
    private const ERROR_CODE_REQUEST_NOT_FOUND = 'REQUEST_NOT_FOUND';
    private const ERROR_CODE_REQUEST_SHIPMENT_NOT_FOUND = 'REQUEST_SHIPMENT_NOT_FOUND';
    private const ERROR_CODE_DELETE_REQUEST_INTERNAL_ERROR = 'DELETE_REQUEST_INTERNAL_ERROR';
    private const ERROR_CODE_PROPERTIES_UNEXPECTED_FORMAT = 'PROPERTIES_UNEXPECTED_FORMAT';
    private const ERROR_CODE_PROPERTY_VALUE_UNEXPECTED_FORMAT = 'PROPERTY_VALUE_UNEXPECTED_FORMAT';
    private const ERROR_CODE_PROPERTY_VALUE_TAGS_UNEXPECTED_FORMAT = 'PROPERTY_VALUE_TAGS_UNEXPECTED_FORMAT';
    private const ERROR_CODE_PROPERTY_VALUE_TAG_UNEXPECTED_FORMAT = 'PROPERTY_VALUE_TAG_UNEXPECTED_FORMAT';
    private const ERROR_CODE_UNEXPECTED_REQUEST_FINALIZE_INDICATOR_VALUE = 'UNEXPECTED_REQUEST_FINALIZE_INDICATOR_VALUE';
    private const ERROR_CODE_UNEXPECTED_OVERWRITE_PROPERTIES_VALUE = 'UNEXPECTED_OVERWRITE_PROPERTIES_VALUE';
    private const ERROR_CODE_EMPTY_UPDATE_PAYLOAD = 'EMPTY_UPDATE_PAYLOAD';
    private const ERROR_CODE_UPDATE_REQUEST_INTERNAL_ERROR = 'UPDATE_REQUEST_INTERNAL_ERROR';
    private const ERROR_CODE_STATUS_UNEXPECTED_FORMAT = 'STATUS_UNEXPECTED_FORMAT';
    private const ERROR_CODE_STATUS_TEXT_NOT_SPECIFIED = 'STATUS_TEXT_NOT_SPECIFIED';
    private const ERROR_CODE_STATUS_SEMANTIC_NOT_SPECIFIED = 'STATUS_SEMANTIC_NOT_SPECIFIED';
    private const ERROR_CODE_DATE_VALUE_UNEXPECTED_FORMAT = 'DATE_VALUE_UNEXPECTED_FORMAT';

    public static function updateRequest($query, $n, \CRestServer $server): bool
    {
        self::checkDeliveryPermission();
        $params = self::prepareIncomingParams($query);
 
        $requestId = self::getRequestId(
            self::getDeliveryId($params, 'DELIVERY_ID'),
            $params,
            'REQUEST_ID'
        );
 
        $fields = [];
 
        if (isset($params['FINALIZE']))
        {
            if (!in_array($params['FINALIZE'], ['Y', 'N'], true))
            {
                throw new RestException(
                    'Unexpected parameter FINALIZE value: Y, N expected',
                    self::ERROR_CODE_UNEXPECTED_REQUEST_FINALIZE_INDICATOR_VALUE
                );
            }
 
            if ($params['FINALIZE'] === 'Y')
            {
                $fields['STATUS'] = Requests\Manager::STATUS_PROCESSED;
            }
        }
 
        $requestStatus = self::getRequestStatus($params, 'STATUS');
        if (!is_null($requestStatus))
        {
            $fields['EXTERNAL_STATUS'] = $requestStatus['TEXT'];
            $fields['EXTERNAL_STATUS_SEMANTIC'] = $requestStatus['SEMANTIC'];
        }
 
        $properties = self::getRequestProperties($params, 'PROPERTIES');
        if (!is_null($properties))
        {
            $fields['EXTERNAL_PROPERTIES'] = $properties;
        }
 
        $overwriteProperties = false;
        if (isset($params['OVERWRITE_PROPERTIES']))
        {
            if (!in_array($params['OVERWRITE_PROPERTIES'], ['Y', 'N'], true))
            {
                throw new RestException(
                    'Unexpected parameter OVERWRITE_PROPERTIES value: Y, N expected',
                    self::ERROR_CODE_UNEXPECTED_OVERWRITE_PROPERTIES_VALUE
                );
            }
            $overwriteProperties = $params['OVERWRITE_PROPERTIES'] === 'Y';
        }
 
        if (empty($fields))
        {
            throw new RestException(
                'Empty update payload',
                self::ERROR_CODE_EMPTY_UPDATE_PAYLOAD
            );
        }
 
        $updateResult = Requests\Manager::updateDeliveryRequest(
            $requestId,
            $fields,
            $overwriteProperties
        );
        if (!$updateResult->isSuccess())
        {
            throw new RestException('Internal error', self::ERROR_CODE_UPDATE_REQUEST_INTERNAL_ERROR);
        }
 
        return true;
    }

    private static function getRequestStatus(array $params, string $key): ?array
    {
        if (!isset($params[$key]))
        {
            return null;
        }
 
        if (!is_array($params[$key]))
        {
            throw new RestException(
                sprintf('Unexpected status (%s) format: array expected', $key),
                self::ERROR_CODE_STATUS_UNEXPECTED_FORMAT
            );
        }
 
        if (empty($params[$key]['TEXT']))
        {
            throw new RestException(
                'Status text has not been specified',
                self::ERROR_CODE_STATUS_TEXT_NOT_SPECIFIED
            );
        }
 
        if (empty($params[$key]['SEMANTIC']))
        {
            throw new RestException(
                'Status semantic has not been specified',
                self::ERROR_CODE_STATUS_SEMANTIC_NOT_SPECIFIED
            );
        }
 
        if (!in_array($params[$key]['SEMANTIC'], Requests\Manager::getRequestStatusSemantics(), true))
        {
            throw new RestException(
                sprintf('Unexpected request status semantic: %s', $params[$key]['SEMANTIC']),
                self::ERROR_CODE_STATUS_SEMANTIC_NOT_SPECIFIED
            );
        }
 
        return [
            'TEXT' => $params[$key]['TEXT'],
            'SEMANTIC' => $params[$key]['SEMANTIC'],
        ];
    }

    private static function getRequestProperties(array $params, string $key): ?array
    {
        if (!isset($params[$key]))
        {
            return null;
        }
 
        if (!is_array($params[$key]))
        {
            throw new RestException(
                sprintf('Unexpected properties (%s) format: array expected', $key),
                self::ERROR_CODE_PROPERTIES_UNEXPECTED_FORMAT
            );
        }
 
        $result = [];
        foreach ($params[$key] as $propertyKey => $propertyValue)
        {
            $isExpectedFormat = (
                is_array($propertyValue)
                && isset($propertyValue['NAME'])
                && is_string($propertyValue['NAME'])
                && !empty($propertyValue['NAME'])
                && isset($propertyValue['VALUE'])
                && is_string($propertyValue['VALUE'])
            );
            if (!$isExpectedFormat)
            {
                throw new RestException(
                    sprintf('Unexpected property value (%s.%s) format', $key, $propertyKey),
                    self::ERROR_CODE_PROPERTY_VALUE_UNEXPECTED_FORMAT
                );
            }
            $resultItem = [
                'NAME' => $propertyValue['NAME'],
                'VALUE' => $propertyValue['VALUE'],
            ];
 
            if (isset($propertyValue['TAGS']))
            {
                if (!is_array($propertyValue['TAGS']))
                {
                    throw new RestException(
                        sprintf(
                            'Unexpected property value\'s tags format (%s.%s) format: array expected',
                            $key,
                            $propertyKey
                        ),
                        self::ERROR_CODE_PROPERTY_VALUE_TAGS_UNEXPECTED_FORMAT
                    );
                }
 
                foreach ($propertyValue['TAGS'] as $tag)
                {
                    if (!is_string($tag))
                    {
                        throw new RestException(
                            sprintf(
                                'Property value (%s.%s) tag must be of string type',
                                $key,
                                $propertyKey
                            ),
                            self::ERROR_CODE_PROPERTY_VALUE_TAG_UNEXPECTED_FORMAT
                        );
                    }
                }
 
                $resultItem['TAGS'] = $propertyValue['TAGS'];
            }
 
            $result[] = $resultItem;
        }
 
        return $result;
    }

    public static function deleteRequest($query, $n, \CRestServer $server): bool
    {
        self::checkDeliveryPermission();
        $params = self::prepareIncomingParams($query);
 
        $deliveryId = self::getDeliveryId($params, 'DELIVERY_ID');
        $requestId = self::getRequestId($deliveryId, $params, 'REQUEST_ID');
 
        $deleteResult = Requests\Manager::deleteDeliveryRequest($requestId);
        if (!$deleteResult->isSuccess())
        {
            throw new RestException('Internal error', self::ERROR_CODE_DELETE_REQUEST_INTERNAL_ERROR);
        }
 
        return true;
    }

    public static function sendMessage($query, $n, \CRestServer $server): bool
    {
        self::checkDeliveryPermission();
        $params = self::prepareIncomingParams($query);
 
        $delivery = self::getDelivery($params, 'DELIVERY_ID');
 
        $requestId = self::getRequestId($delivery->getId(), $params, 'REQUEST_ID');
 
        Requests\Manager::sendMessage(
            self::getAddressee($params, 'ADDRESSEE'),
            self::getMessage($params, 'MESSAGE')->setCurrency($delivery->getCurrency()),
            $requestId,
            self::getShipmentId($requestId, $params, 'SHIPMENT_REQUEST_ID')
        );
 
        return true;
    }

    private static function getDeliveryId(array $params, string $key): int
    {
        $delivery = self::getDelivery($params, $key);
 
        return $delivery->getId();
    }

    private static function getDelivery(array $params, string $key): Delivery\Services\Base
    {
        if (!isset($params[$key]))
        {
            throw new RestException(
                sprintf('Parameter %s is not specified', $key),
                self::ERROR_CODE_DELIVERY_ID_NOT_SPECIFIED
            );
        }

        $delivery = Delivery\Services\Manager::getObjectById((int)$params[$key]);
        if (!$delivery)
        {
            throw new RestException(
                'Delivery service has not been found',
                self::ERROR_CODE_DELIVERY_NOT_FOUND
            );
        }
 
        return $delivery;
    }

    private static function getAddressee(array $params, string $key): string
    {
        if (empty($params[$key]))
        {
            throw new RestException(
                sprintf('Parameter %s is not specified', $key),
                self::ERROR_CODE_ADDRESSEE_IS_NOT_SPECIFIED
            );
        }
 
        if (!in_array($params[$key], Requests\Manager::getMessageAddressees(), true))
        {
            throw new RestException(
                sprintf('Unexpected %s parameter value', $key),
                self::ERROR_CODE_ADDRESSEE_UNEXPECTED_VALUE
            );
        }
 
        return $params[$key];
    }

    private static function getRequestId(int $deliveryId, array $params, string $key): int
    {
        if (empty($params[$key]))
        {
            throw new RestException(
                sprintf('Parameter %s is not specified', $key),
                self::ERROR_CODE_REQUEST_ID_NOT_SPECIFIED
            );
        }
 
        $requestList = Requests\RequestTable::getList([
            'filter' => [
                '=DELIVERY_ID' => $deliveryId,
                '=EXTERNAL_ID' => $params[$key],
            ]
        ]);
        $request = $requestList->fetch();
 
        if (!$request)
        {
            throw new RestException(
                'Request has not been found',
                self::ERROR_CODE_REQUEST_NOT_FOUND
            );
        }
 
        return (int)$request['ID'];
    }

    private static function getShipmentId(int $requestId, array $params, string $key): int
    {
        $requestShipmentFilter = ['=REQUEST_ID' => $requestId];
        if (isset($params[$key]))
        {
            $requestShipmentFilter['=EXTERNAL_ID'] = (int)$params[$key];
        }
        $requestShipment = Requests\ShipmentTable::getList(['filter' => $requestShipmentFilter])->fetch();
        if (!$requestShipment)
        {
            throw new RestException(
                'Shipment has not been found',
                self::ERROR_CODE_REQUEST_SHIPMENT_NOT_FOUND
            );
        }
 
        return (int)$requestShipment['SHIPMENT_ID'];
    }

    private static function getMessage(array $params, string $key): Requests\Message\Message
    {
        if (
            !isset($params[$key])
            || !is_array($params[$key])
            || (
                (!is_string($params[$key]['SUBJECT']) || empty($params[$key]['SUBJECT']))
                && (!is_string($params[$key]['BODY']) || empty($params[$key]['BODY']))
            )
        )
        {
            throw new RestException(
                sprintf('Parameter %s is not specified', $key),
                self::ERROR_CODE_MESSAGE_NOT_SPECIFIED
            );
        }
 
        $message = new Requests\Message\Message();
 
        if (!empty($params[$key]['SUBJECT']))
        {
            $message->setSubject($params[$key]['SUBJECT']);
        }
        if (!empty($params[$key]['BODY']))
        {
            $message->setBody($params[$key]['BODY']);
        }
 
        if (isset($params[$key]['MONEY_VALUES']) && is_array($params[$key]['MONEY_VALUES']))
        {
            foreach ($params[$key]['MONEY_VALUES'] as $moneyKey => $moneyValue)
            {
                $message->addMoneyValue(
                    (string)$moneyKey,
                    (float)$moneyValue
                );
            }
        }
 
        if (isset($params[$key]['DATE_VALUES']) && is_array($params[$key]['DATE_VALUES']))
        {
            foreach ($params[$key]['DATE_VALUES'] as $dateKey => $dateValue)
            {
                if (!isset($dateValue['VALUE']) || !isset($dateValue['FORMAT']))
                {
                    throw new RestException(
                        'Unexpected date value format',
                        self::ERROR_CODE_DATE_VALUE_UNEXPECTED_FORMAT
                    );
                }
 
                $message->addDateValue(
                    (string)$dateKey,
                    (int)$dateValue['VALUE'],
                    (string)$dateValue['FORMAT']
                );
            }
        }
 
        if (isset($params[$key]['STATUS']))
        {
            if (!is_string($params[$key]['STATUS']['MESSAGE']) || empty($params[$key]['STATUS']['MESSAGE']))
            {
                throw new RestException(
                    'Status message is not specified',
                    self::ERROR_CODE_MESSAGE_STATUS_NOT_SPECIFIED
                );
            }
 
            if (!is_string($params[$key]['STATUS']['SEMANTIC']) || empty($params['MESSAGE']['STATUS']['SEMANTIC']))
            {
                throw new RestException(
                    'Message status semantic is not specified',
                    self::ERROR_CODE_MESSAGE_STATUS_SEMANTIC_NOT_SPECIFIED
                );
            }
 
            if (!in_array($params[$key]['STATUS']['SEMANTIC'], Requests\Message\Status::getAvailableSemantics(), true))
            {
                throw new RestException(
                    sprintf('Unexpected message status semantic: %s', $params['MESSAGE']['STATUS']['SEMANTIC']),
                    self::ERROR_CODE_UNEXPECTED_MESSAGE_STATUS_SEMANTIC
                );
            }
 
            $message->setStatus(
                new Requests\Message\Status(
                    $params[$key]['STATUS']['MESSAGE'],
                    $params[$key]['STATUS']['SEMANTIC']
                )
            );
        }
 
        return $message;
    }
}