goetas-webservices / soap-common

src/Headers/Handler/HeaderHandler.php

<?php

declare(strict_types=1);

namespace GoetasWebservices\SoapServices\Metadata\Headers\Handler;

use GoetasWebservices\SoapServices\Metadata\Envelope\Envelope;
use GoetasWebservices\SoapServices\Metadata\Headers\Header;
use GoetasWebservices\SoapServices\Metadata\Headers\HeadersIncoming;
use GoetasWebservices\SoapServices\Metadata\Headers\HeadersOutgoing;
use JMS\Serializer\DeserializationContext;
use JMS\Serializer\EventDispatcher\EventSubscriberInterface;
use JMS\Serializer\EventDispatcher\PreSerializeEvent;
use JMS\Serializer\GraphNavigator;
use JMS\Serializer\Handler\SubscribingHandlerInterface;
use JMS\Serializer\Metadata\StaticPropertyMetadata;
use JMS\Serializer\SerializationContext;
use JMS\Serializer\Visitor\DeserializationVisitorInterface;
use JMS\Serializer\Visitor\SerializationVisitorInterface;

class HeaderHandler implements SubscribingHandlerInterface, EventSubscriberInterface
{
    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [
            ['event' => 'serializer.pre_serialize', 'method' => 'ensureHeaderSerialized', 'interface' => Envelope::class],
        ];
    }

    public static function getSubscribingMethods(): array
    {
        return [
            [
                'direction' => GraphNavigator::DIRECTION_DESERIALIZATION,
                'format' => 'xml',
                'type' => 'GoetasWebservices\SoapServices\Metadata\Headers\RawFaultDetail',
                'method' => 'deserializeFaultDetail',
            ],
            [
                'direction' => GraphNavigator::DIRECTION_SERIALIZATION,
                'format' => 'xml',
                'type' => 'GoetasWebservices\SoapServices\Metadata\Headers\Handler\HeaderPlaceholder',
                'method' => 'serializeHeaderPlaceholder',
            ],
            [
                'direction' => GraphNavigator::DIRECTION_DESERIALIZATION,
                'format' => 'xml',
                'type' => 'GoetasWebservices\SoapServices\Metadata\Headers\Handler\HeaderPlaceholder',
                'method' => 'deserializeHeaderPlaceholder',
            ],
            [
                'direction' => GraphNavigator::DIRECTION_DESERIALIZATION,
                'format' => 'xml',
                'type' => 'GoetasWebservices\SoapServices\SoapEnvelope\Header',
                'method' => 'deserializeHeader',
            ],
            [
                'direction' => GraphNavigator::DIRECTION_SERIALIZATION,
                'format' => 'xml',
                'type' => Header::class,
                'method' => 'serializeHeader',
            ],
        ];
    }

    public function ensureHeaderSerialized(PreSerializeEvent $event): void
    {
        $envelope = $event->getObject();
        if (!($envelope instanceof Envelope)) {
            return;
        }

        $context = $event->getContext();
        $headerBag = $context->getAttribute('headers_outgoing');
        \assert($headerBag instanceof HeadersOutgoing);

        if (count($headerBag->getHeaders()) > 0 && !$envelope->getHeader()) {

The method getHeader() does not exist on GoetasWebservices\SoapServices\Metadata\Envelope\Envelope.

            $factory = $event->getContext()->getMetadataFactory();
            $envelopeMetadata = $factory->getMetadataForClass($event->getType()['name']);
            $headerType = $envelopeMetadata->propertyMetadata['header']->type;

The property propertyMetadata does not seem to exist on Metadata\ClassHierarchyMetadata.

            $defaultHeaderClass = $headerType['params'][0];
            $envelope->setHeader(new $defaultHeaderClass());

The method setHeader() does not exist on GoetasWebservices\SoapServices\Metadata\Envelope\Envelope.

        }
    }

    /**
     * @return mixed
     */
    public function deserializeHeaderPlaceholder(DeserializationVisitorInterface $visitor, \SimpleXMLElement $data, array $type, DeserializationContext $context)
    {
        $type = ['name' => $type['params'][0], 'params' => []];
        $headers = $context->getNavigator()->accept($data, $type, $context);

The call to JMS\Serializer\GraphNavigatorInterface::accept() has too many arguments starting with $context.

        $headerBag = $context->getAttribute('headers_incoming');
        \assert($headerBag instanceof HeadersIncoming);

        foreach ($data->xpath('./*') as $node) {
            if ($this->isMustUnderstand($node, $visitor, $context)) {
                $headerBag->addMustUnderstandHeader($node);
            } else {
                $headerBag->addHeader($node);
            }
        }

        return $headers;
    }

    /**
     * @return mixed
     */
    public function deserializeHeader(DeserializationVisitorInterface $visitor, \SimpleXMLElement $data, array $type, DeserializationContext $context)
    {
        $type = ['name' => $type['params'][0], 'params' => []];

        $return = $context->getNavigator()->accept($data, $type, $context);

The call to JMS\Serializer\GraphNavigatorInterface::accept() has too many arguments starting with $context.

        $headerBag = $context->getAttribute('headers_incoming');
        \assert($headerBag instanceof HeadersIncoming);

        if ($this->isMustUnderstand($data, $visitor, $context)) {
            $headerBag->addMustUnderstandHeader($data, $return);
        } else {
            $headerBag->addHeader($data, $return);
        }

        return $return;
    }

    private function isMustUnderstand(\SimpleXMLElement $data, DeserializationVisitorInterface $visitor, DeserializationContext $context): bool
    {
        $domElement = dom_import_simplexml($data);
        $mustUnderstandAttr = $domElement->getAttributeNS($domElement->ownerDocument->documentElement->namespaceURI, 'mustUnderstand');

        return !empty($mustUnderstandAttr) && $visitor->visitBoolean($mustUnderstandAttr, [], $context);

The call to JMS\Serializer\Visitor\DeserializationVisitorInterface::visitBoolean() has too many arguments starting with $context.

    }

    public function serializeHeaderPlaceholder(SerializationVisitorInterface $visitor, object $data, array $type, SerializationContext $context): void
    {
        // serialize default headers
        $context->stopVisiting($data);
        $type = ['name' => $type['params'][0], 'params' => []];
        $context->getNavigator()->accept($data, $type, $context);

The call to JMS\Serializer\GraphNavigatorInterface::accept() has too many arguments starting with $context.

        $context->startVisiting($data);

        // serialize additional headers
        $headerBag = $context->getAttribute('headers_outgoing');
        \assert($headerBag instanceof HeadersOutgoing);

        $factory = $context->getMetadataFactory();
        foreach ($headerBag->getHeaders() as $header) {
            $classMetadata = $factory->getMetadataForClass(get_class($header->getData()));

            $name = false !== ($pos = strpos($classMetadata->xmlRootName, ':')) ? substr($classMetadata->xmlRootName, $pos + 1) : $classMetadata->xmlRootName;

The property xmlRootName does not seem to exist on Metadata\ClassHierarchyMetadata.

            $metadata = new StaticPropertyMetadata($classMetadata->name, $name, $header->getData());

The property name does not seem to exist on Metadata\ClassHierarchyMetadata.

            $metadata->xmlNamespace = $classMetadata->xmlRootNamespace;

The property xmlRootNamespace does not seem to exist on Metadata\ClassHierarchyMetadata.

            $metadata->serializedName = $name;

            $visitor->visitProperty($metadata, $header->getData(), $context);

The call to JMS\Serializer\Visitor\SerializationVisitorInterface::visitProperty() has too many arguments starting with $context.

            $this->handleOptions($visitor, $header->getOptions());
        }
    }

    public function serializeHeader(SerializationVisitorInterface $visitor, Header $header, array $type, SerializationContext $context): void

The parameter $type is not used and could be removed.

    {
        $data = $header->getData();
        if ($data instanceof \DOMDocument) {
            $data = $data->documentElement;
        }

        if ($data instanceof \DOMElement) {
            $importedNode = $data->ownerDocument !== $visitor->getDocument()

The method getDocument() does not exist on JMS\Serializer\Visitor\SerializationVisitorInterface. It seems like you code against a sub-type of JMS\Serializer\Visitor\SerializationVisitorInterface such as JMS\Serializer\XmlSerializationVisitor.

                ? $visitor->getDocument()->importNode($data, true)
                : $data;
            $visitor->getCurrentNode()->appendChild($importedNode);

The method getCurrentNode() does not exist on JMS\Serializer\Visitor\SerializationVisitorInterface. It seems like you code against a sub-type of JMS\Serializer\Visitor\SerializationVisitorInterface such as JMS\Serializer\XmlSerializationVisitor.

        } else {
            $factory = $context->getMetadataFactory();
            /**
             * @var $classMetadata \JMS\Serializer\Metadata\ClassMetadata
             */
            $classMetadata = $factory->getMetadataForClass(get_class($header->getData()));

            $name = false !== ($pos = strpos($classMetadata->xmlRootName, ':')) ? substr($classMetadata->xmlRootName, $pos + 1) : $classMetadata->xmlRootName;

            $metadata = new StaticPropertyMetadata($classMetadata->name, $name, $header->getData());
            $metadata->xmlNamespace = $classMetadata->xmlRootNamespace;
            $metadata->serializedName = $name;

            $visitor->visitProperty($metadata, $data, $context);

The call to JMS\Serializer\Visitor\SerializationVisitorInterface::visitProperty() has too many arguments starting with $context.

            $this->handleOptions($visitor, $header->getOptions());
        }
    }

    private function handleOptions(SerializationVisitorInterface $visitor, array $options): void
    {
        if (!count($options)) {
            return;
        }

        /**
         * @var $currentNode \DOMNode
         */
        $currentNode = $visitor->getCurrentNode();
        foreach ($options as $option => $value) {
            if (in_array($option, ['mustUnderstand', 'required', 'role', 'actor'])) {
                $this->setAttributeOnNode($currentNode->lastChild, $option, $value, $currentNode->ownerDocument->documentElement->namespaceURI);

It seems like $currentNode->lastChild can also be of type null; however, parameter $node of GoetasWebservices\SoapServices\Metadata\Headers\Handler\HeaderHandler::setAttributeOnNode() does only seem to accept DOMElement, maybe add an additional type check?

It seems like $currentNode->ownerDocument->documentElement->namespaceURI can also be of type null; however, parameter $namespace of GoetasWebservices\SoapServices\Metadata\Headers\Handler\HeaderHandler::setAttributeOnNode() does only seem to accept string, maybe add an additional type check?

            }
        }
    }

    /**
     * @param mixed $value
     */
    private function setAttributeOnNode(\DOMElement $node, string $name, $value, string $namespace): void
    {
        if (!($prefix = $node->lookupPrefix($namespace)) && !($prefix = $node->ownerDocument->lookupPrefix($namespace))) {

The method lookupPrefix() does not exist on null.

            $prefix = 'ns-' . substr(sha1($namespace), 0, 8);
        }

        $node->setAttributeNS($namespace, $prefix . ':' . $name, is_bool($value) || null === $value ? ($value ? 'true' : 'false') : $value);
    }

    public function deserializeFaultDetail(DeserializationVisitorInterface $visitor, \SimpleXMLElement $data, array $type, DeserializationContext $context): \SimpleXMLElement

The parameter $visitor is not used and could be removed.

The parameter $context is not used and could be removed.

The parameter $type is not used and could be removed.

    {
        return $data->children();
    }
}