Request.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Webapi\Rest;

use Magento\Framework\Api\SimpleDataObjectConverter;
use Magento\Framework\Phrase;

class Request extends \Magento\Framework\Webapi\Request
{
    const HTTP_METHOD_GET = 'GET';
    const HTTP_METHOD_DELETE = 'DELETE';
    const HTTP_METHOD_PUT = 'PUT';
    const HTTP_METHOD_POST = 'POST';
    const REQUEST_CHARSET = 'utf-8';

    const DEFAULT_ACCEPT = '*/*';

    protected $_serviceName;

    protected $_serviceType;

    protected $_deserializer;

    protected $_bodyParams;

    protected $_deserializerFactory;

    public function __construct(
        \Magento\Framework\Stdlib\Cookie\CookieReaderInterface $cookieReader,
        \Magento\Framework\Stdlib\StringUtils $converter,
        \Magento\Framework\App\AreaList $areaList,
        \Magento\Framework\Config\ScopeInterface $configScope,
        \Magento\Framework\Webapi\Rest\Request\DeserializerFactory $deserializerFactory,
        $uri = null
    ) {
        parent::__construct($cookieReader, $converter, $areaList, $configScope, $uri);
        $this->_deserializerFactory = $deserializerFactory;
    }

    protected function _getDeserializer()
    {
        if (null === $this->_deserializer) {
            $this->_deserializer = $this->_deserializerFactory->get($this->getContentType());
        }
        return $this->_deserializer;
    }

    public function getAcceptTypes()
    {
        $qualityToTypes = [];
        $orderedTypes = [];

        foreach (preg_split('/,\s*/', $this->getHeader('Accept')) as $definition) {
            $typeWithQ = explode(';', $definition);
            $mimeType = trim(array_shift($typeWithQ));

            // check MIME type validity
            if (!preg_match('~^([0-9a-z*+\-]+)(?:/([0-9a-z*+\-\.]+))?$~i', $mimeType)) {
                continue;
            }
            $quality = '1.0';
            // default value for quality

            if ($typeWithQ) {
                $qAndValue = explode('=', $typeWithQ[0]);

                if (2 == count($qAndValue)) {
                    $quality = $qAndValue[1];
                }
            }
            $qualityToTypes[$quality][$mimeType] = true;
        }
        krsort($qualityToTypes);

        foreach ($qualityToTypes as $typeList) {
            $orderedTypes += $typeList;
        }
        return empty($orderedTypes) ? [self::DEFAULT_ACCEPT] : array_keys($orderedTypes);
    }

    public function getBodyParams()
    {
        if (null == $this->_bodyParams) {
            $this->_bodyParams = [];
            //avoid JSON decoding with empty string
            if ($this->getContent()) {
                $this->_bodyParams = (array)$this->_getDeserializer()->deserialize((string)$this->getContent());
            }
        }
        return $this->_bodyParams;
    }

    public function getContentType()
    {
        $headerValue = $this->getHeader('Content-Type');

        if (!$headerValue) {
            throw new \Magento\Framework\Exception\InputException(new Phrase('Content-Type header is empty.'));
        }
        if (!preg_match('~^([a-z\d/\-+.]+)(?:; *charset=(.+))?$~Ui', $headerValue, $matches)) {
            throw new \Magento\Framework\Exception\InputException(new Phrase('Content-Type header is invalid.'));
        }
        // request encoding check if it is specified in header
        if (isset($matches[2]) && self::REQUEST_CHARSET != strtolower($matches[2])) {
            throw new \Magento\Framework\Exception\InputException(new Phrase('UTF-8 is the only supported charset.'));
        }

        return $matches[1];
    }

    public function getHttpMethod()
    {
        if (!$this->isGet() && !$this->isPost() && !$this->isPut() && !$this->isDelete()) {
            throw new \Magento\Framework\Exception\InputException(new Phrase('Request method is invalid.'));
        }
        return $this->getMethod();
    }

    public function getRequestData()
    {
        $requestBodyParams = [];
        $params = $this->getParams();

        $httpMethod = $this->getHttpMethod();
        if ($httpMethod == self::HTTP_METHOD_POST ||
            $httpMethod == self::HTTP_METHOD_PUT
        ) {
            $requestBodyParams = $this->getBodyParams();
        }

        return array_merge($requestBodyParams, $params);
    }

    protected function overrideRequestBodyIdWithPathParam($urlPathParams)
    {
        $requestBodyParams = $this->getBodyParams();
        $pathParamValue = end($urlPathParams);
        // Self apis should not be overridden
        if ($pathParamValue === 'me') {
            return $requestBodyParams;
        }
        $pathParamKey = key($urlPathParams);
        // Check if the request data is a top level object of body
        if (count($requestBodyParams) == 1 && is_array(end($requestBodyParams))) {
            $requestDataKey = key($requestBodyParams);
            $this->substituteParameters($requestBodyParams[$requestDataKey], $pathParamKey, $pathParamValue);
        } else { // Else parameters passed as scalar values in body will be overridden
            $this->substituteParameters($requestBodyParams, $pathParamKey, $pathParamValue);
        }

        return $requestBodyParams;
    }

    protected function substituteParameters(&$requestData, $key, $value)
    {
        $snakeCaseKey = SimpleDataObjectConverter::camelCaseToSnakeCase($key);
        $camelCaseKey = SimpleDataObjectConverter::snakeCaseToCamelCase($key);

        if (isset($requestData[$camelCaseKey])) {
            $requestData[$camelCaseKey] = $value;
        } else {
            $requestData[$snakeCaseKey] = $value;
        }
    }
}