ServiceMetadata.php

Go to the documentation of this file.

<?php
declare(strict_types=1);

namespace Magento\WebapiAsync\Plugin;

use Magento\Webapi\Model\Config\Converter as WebapiConverter;
use Magento\AsynchronousOperations\Api\Data\AsyncResponseInterface;
use Magento\WebapiAsync\Controller\Rest\AsynchronousSchemaRequestProcessor;
use Magento\WebapiAsync\Model\ServiceConfig\Converter;

class ServiceMetadata
{
    private $webapiConfig;
    private $serviceConfig;
    private $asynchronousSchemaRequestProcessor;
    private $request;
    private $typeProcessor;
    private $responseDefinitionReplacement;
    private $synchronousOnlyHttpMethods = [
        'GET'
    ];

    public function __construct(
        \Magento\Webapi\Model\Config $webapiConfig,
        \Magento\WebapiAsync\Model\ServiceConfig $serviceConfig,
        \Magento\Framework\Webapi\Rest\Request $request,
        AsynchronousSchemaRequestProcessor $asynchronousSchemaRequestProcessor,
        \Magento\Framework\Reflection\TypeProcessor $typeProcessor
    ) {
        $this->webapiConfig = $webapiConfig;
        $this->serviceConfig = $serviceConfig;
        $this->request = $request;
        $this->asynchronousSchemaRequestProcessor = $asynchronousSchemaRequestProcessor;
        $this->typeProcessor = $typeProcessor;
    }

    public function afterGetServicesConfig(\Magento\Webapi\Model\ServiceMetadata $subject, array $result)
    {
        if ($this->asynchronousSchemaRequestProcessor->canProcess($this->request)) {
            $synchronousOnlyServiceMethods = $this->getSynchronousOnlyServiceMethods($subject);
            // Replace all results with the async response schema
            foreach ($result as $serviceName => $serviceData) {
                // Check all of the methods on the service
                foreach ($serviceData[WebapiConverter::KEY_METHODS] as $methodName => $methodData) {
                    // Exclude service methods that are marked as synchronous only
                    if ($this->isServiceMethodSynchronousOnly(
                        $serviceName,
                        $methodName,
                        $synchronousOnlyServiceMethods
                    )) {
                        $this->removeServiceMethodDefinition($result, $serviceName, $methodName);
                    } else {
                        $this->replaceResponseDefinition($result, $serviceName, $methodName);
                    }
                }
            }
        }

        return $result;
    }

    private function isServiceMethodSynchronousOnly($serviceName, $methodName, array $synchronousOnlyServiceMethods)
    {
        return isset($synchronousOnlyServiceMethods[$serviceName][$methodName]);
    }

    private function getServiceVersions(string $serviceName)
    {
        $services = $this->webapiConfig->getServices();

        return array_keys($services[WebapiConverter::KEY_SERVICES][$serviceName]);
    }

    private function getSynchronousOnlyServiceMethods(\Magento\Webapi\Model\ServiceMetadata $serviceMetadata)
    {
        $synchronousOnlyServiceMethods = [];
        $services = $this->serviceConfig->getServices()[Converter::KEY_SERVICES] ?? [];
        foreach ($services as $service => $serviceData) {
            if (!isset($serviceData[Converter::KEY_METHODS])) {
                continue;
            }

            foreach ($serviceData[Converter::KEY_METHODS] as $method => $methodData) {
                if ($this->isMethodDataSynchronousOnly($methodData)) {
                    $this->appendSynchronousOnlyServiceMethodsWithInterface(
                        $serviceMetadata,
                        $synchronousOnlyServiceMethods,
                        $service,
                        $method
                    );
                }
            }
        }

        return array_merge_recursive(
            $synchronousOnlyServiceMethods,
            $this->getSynchronousOnlyRoutesAsServiceMethods($serviceMetadata)
        );
    }

    private function getSynchronousOnlyRoutesAsServiceMethods(
        \Magento\Webapi\Model\ServiceMetadata $serviceMetadata
    ) {
        $synchronousOnlyServiceMethods = [];
        $serviceRoutes = $this->webapiConfig->getServices()[\Magento\Webapi\Model\Config\Converter::KEY_ROUTES];
        foreach ($serviceRoutes as $serviceRoutePath => $serviceRouteMethods) {
            foreach ($serviceRouteMethods as $serviceRouteMethod => $serviceRouteMethodData) {
                // Check if the HTTP method associated with the route is not able to be async.
                if (in_array(strtoupper($serviceRouteMethod), $this->synchronousOnlyHttpMethods)) {
                    $this->appendSynchronousOnlyServiceMethodsWithInterface(
                        $serviceMetadata,
                        $synchronousOnlyServiceMethods,
                        $serviceRouteMethodData[WebapiConverter::KEY_SERVICE][WebapiConverter::KEY_SERVICE_CLASS],
                        $serviceRouteMethodData[WebapiConverter::KEY_SERVICE][WebapiConverter::KEY_SERVICE_METHOD]
                    );
                }
            }
        }

        return $synchronousOnlyServiceMethods;
    }

    private function appendSynchronousOnlyServiceMethodsWithInterface(
        \Magento\Webapi\Model\ServiceMetadata $serviceMetadata,
        array &$synchronousOnlyServiceMethods,
        $serviceInterface,
        $serviceMethod
    ) {
        foreach ($this->getServiceVersions($serviceInterface) as $serviceVersion) {
            $serviceName = $serviceMetadata->getServiceName($serviceInterface, $serviceVersion);
            if (!array_key_exists($serviceName, $synchronousOnlyServiceMethods)) {
                $synchronousOnlyServiceMethods[$serviceName] = [];
            }

            $synchronousOnlyServiceMethods[$serviceName][$serviceMethod] = true;
        }
    }

    private function removeServiceMethodDefinition(array &$result, $serviceName, $methodName)
    {
        unset($result[$serviceName][WebapiConverter::KEY_METHODS][$methodName]);

        // Remove the service altogether if there is no methods left.
        if (count($result[$serviceName][WebapiConverter::KEY_METHODS]) === 0) {
            unset($result[$serviceName]);
        }
    }

    private function replaceResponseDefinition(array &$result, $serviceName, $methodName)
    {
        if (isset($result[$serviceName][WebapiConverter::KEY_METHODS][$methodName]['interface']['out'])) {
            $replacement = $this->getResponseDefinitionReplacement();
            $result[$serviceName][WebapiConverter::KEY_METHODS][$methodName]['interface']['out'] = $replacement;
        }
    }

    private function isMethodDataSynchronousOnly(array $methodData)
    {
        if (!isset($methodData[Converter::KEY_SYNCHRONOUS_INVOCATION_ONLY])) {
            return false;
        }

        return $methodData[Converter::KEY_SYNCHRONOUS_INVOCATION_ONLY];
    }

    private function getResponseDefinitionReplacement()
    {
        if ($this->responseDefinitionReplacement === null) {
            $this->responseDefinitionReplacement = [
                'parameters' => [
                    'result' => [
                        'type' => $this->typeProcessor->register(AsyncResponseInterface::class),
                        'documentation' => 'Returns response information for the asynchronous request.',
                        'required' => true,
                        'response_codes' => [
                            'success' => [
                                'code' => '202',
                                'description' => '202 Accepted.'
                            ]
                        ]
                    ]
                ]
            ];
        }

        return $this->responseDefinitionReplacement;
    }
}