Converter.php

Go to the documentation of this file.

<?php
declare(strict_types=1);

namespace Magento\WebapiAsync\Model\ServiceConfig;

class Converter implements \Magento\Framework\Config\ConverterInterface
{
    const KEY_SERVICES = 'services';
    const KEY_METHOD = 'method';
    const KEY_METHODS = 'methods';
    const KEY_SYNCHRONOUS_INVOCATION_ONLY = 'synchronousInvocationOnly';
    const KEY_ROUTES = 'routes';
    private $allowedRouteMethods = [
        \Magento\Webapi\Model\Rest\Config::HTTP_METHOD_GET,
        \Magento\Webapi\Model\Rest\Config::HTTP_METHOD_POST,
        \Magento\Webapi\Model\Rest\Config::HTTP_METHOD_PUT,
        \Magento\Webapi\Model\Rest\Config::HTTP_METHOD_DELETE,
        \Magento\Webapi\Model\Rest\Config::HTTP_METHOD_PATCH
    ];

    public function convert($source)
    {
        $result = [self::KEY_SERVICES => []];
        $services = $source->getElementsByTagName('service');
        foreach ($services as $service) {
            if (!$this->canConvertXmlNode($service)) {
                continue;
            }
            $serviceClass = $this->getServiceClass($service);
            $serviceMethod = $this->getServiceMethod($service);

            // Define the service method's key if this hasn't yet been defined
            $this->initServiceMethodsKey($result, $serviceClass, $serviceMethod);
            $this->mergeSynchronousInvocationMethodsData($service, $result, $serviceClass, $serviceMethod);
        }
        $result[self::KEY_ROUTES] = $this->convertRouteCustomizations($source);

        return $result;
    }

    private function mergeSynchronousInvocationMethodsData(
        \DOMElement $service,
        array &$result,
        $serviceClass,
        $serviceMethod
    ) {
        $result[self::KEY_SERVICES][$serviceClass][self::KEY_METHODS][$serviceMethod] = array_merge(
            $result[self::KEY_SERVICES][$serviceClass][self::KEY_METHODS][$serviceMethod],
            [
                self::KEY_SYNCHRONOUS_INVOCATION_ONLY => $this->isSynchronousMethodInvocationOnly($service)
            ]
        );
    }

    private function canConvertXmlNode(\DOMElement $node)
    {
        if ($node->nodeType !== XML_ELEMENT_NODE) {
            return false;
        }

        if ($this->getServiceClass($node) === null) {
            return false;
        }

        if ($this->getServiceMethod($node) === null) {
            return false;
        }

        return true;
    }

    private function initServiceMethodsKey(array &$result, $serviceClass, $serviceMethod)
    {
        if (!isset($result[self::KEY_SERVICES][$serviceClass])) {
            $result[self::KEY_SERVICES][$serviceClass] = [self::KEY_METHODS => []];
        }

        if (!isset($result[self::KEY_SERVICES][$serviceClass][self::KEY_METHODS][$serviceMethod])) {
            $result[self::KEY_SERVICES][$serviceClass][self::KEY_METHODS][$serviceMethod] = [];
        }
    }

    private function getServiceClass(\DOMElement $service)
    {
        $serviceClass = $service->attributes->getNamedItem('class')->nodeValue;

        return mb_strlen((string) $serviceClass) === 0 ? null : $serviceClass;
    }

    private function getServiceMethod(\DOMElement $service)
    {
        $serviceMethod = $service->attributes->getNamedItem('method')->nodeValue;

        return mb_strlen((string) $serviceMethod) === 0 ? null : $serviceMethod;
    }

    private function isSynchronousMethodInvocationOnly(\DOMElement $serviceNode)
    {
        $synchronousInvocationOnlyNodes = $serviceNode->getElementsByTagName('synchronousInvocationOnly');

        return $this->isSynchronousInvocationOnlyTrue($synchronousInvocationOnlyNodes->item(0));
    }

    private function isSynchronousInvocationOnlyTrue(\DOMElement $synchronousInvocationOnlyNode = null)
    {
        if ($synchronousInvocationOnlyNode === null) {
            return false;
        }

        if (mb_strlen((string) $synchronousInvocationOnlyNode->nodeValue) === 0) {
            return true;
        }

        return filter_var($synchronousInvocationOnlyNode->nodeValue, FILTER_VALIDATE_BOOLEAN);
    }

    private function convertRouteCustomizations($source)
    {
        $customRoutes = [];
        $routes = $source->getElementsByTagName('route');
        foreach ($routes as $route) {
            $routeUrl = $this->getRouteUrl($route);
            $routeMethod = $this->getRouteMethod($route);
            $routeAlias = $this->getRouteAlias($route);
            if ($routeUrl && $routeMethod && $routeAlias) {
                if (!isset($customRoutes[$routeAlias])) {
                    $customRoutes[$routeAlias] = [];
                }
                $customRoutes[$routeAlias][$routeMethod] = $routeUrl;
            }
        }
        return $customRoutes;
    }

    private function getRouteUrl($route)
    {
        $url = $route->attributes->getNamedItem('url')->nodeValue;
        return mb_strlen((string) $url) === 0 ? null : $url;
    }

    private function getRouteAlias($route)
    {
        $alias = $route->attributes->getNamedItem('alias')->nodeValue;
        return mb_strlen((string) $alias) === 0 ? null : ltrim($alias, '/');
    }

    private function getRouteMethod($route)
    {
        $method = $route->attributes->getNamedItem('method')->nodeValue;
        $method =  mb_strlen((string) $method) === 0 ? null : $method;
        return ($this->validateRouteMethod($method)) ? $method : null;
    }

    private function validateRouteMethod($method)
    {
        return in_array($method, $this->allowedRouteMethods);
    }
}