Sulu\Component\DocumentManager\Subscriber\Core\MappingSubscriber

Complexity

Total Complexity

29

Size/Duplication

Total Lines	267
Duplicated Lines	29.21 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	6
Bugs	4	Features	2

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	getSubscribedEvents()	0	7	1
A	handlePersist()	13	21	4
B	persistReference()	0	31	4
A	persistGeneric()	17	17	2
B	handleHydrate()	13	31	5
B	hydrateReferenceField()	26	26	3
A	hydrateGenericField()	0	19	2
A	getDefaultValue()	0	8	3
A	validateFieldValue()	9	12	4

<?php

namespace Sulu\Component\DocumentManager\Subscriber\Core;

use PHPCR\NodeInterface;
use Sulu\Component\DocumentManager\DocumentAccessor;
use Sulu\Component\DocumentManager\DocumentRegistry;
use Sulu\Component\DocumentManager\Event\AbstractMappingEvent;
use Sulu\Component\DocumentManager\Event\PersistEvent;
use Sulu\Component\DocumentManager\Events;
use Sulu\Component\DocumentManager\Exception\InvalidLocaleException;
use Sulu\Component\DocumentManager\MetadataFactoryInterface;
use Sulu\Component\DocumentManager\PropertyEncoder;
use Sulu\Component\DocumentManager\ProxyFactory;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

/**
 * This subscriber uses the field map in the metadata to map fields from
 * the PHPCR nodes to the document and vice-versa.
 */
class MappingSubscriber implements EventSubscriberInterface
{
    /**
     * @var MetadataFactoryInterface
     */
    private $factory;

    /**
     * @var PropertyEncoder
     */
    private $encoder;

    /**
     * @var ProxyFactory
     */
    private $proxyFactory;

    /**
     * @var DocumentRegistry
     */
    private $documentRegistry;

    /**
     * @param MetadataFactoryInterface $factory
     * @param PropertyEncoder $encoder
     * @param ProxyFactory $proxyFactory
     * @param DocumentRegistry $documentRegistry
     */
    public function __construct(
        MetadataFactoryInterface $factory,
        PropertyEncoder $encoder,
        ProxyFactory $proxyFactory,
        DocumentRegistry $documentRegistry
    ) {
        $this->factory = $factory;
        $this->encoder = $encoder;
        $this->proxyFactory = $proxyFactory;
        $this->documentRegistry = $documentRegistry;
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [
            Events::HYDRATE => ['handleHydrate', -100],
            Events::PERSIST => ['handlePersist', -100],
        ];
    }

    /**
     * @param PersistEvent $event
     */
    public function handlePersist(PersistEvent $event)
    {
        $metadata = $this->factory->getMetadataForClass(get_class($event->getDocument()));
        $locale = $event->getLocale();
        $node = $event->getNode();
        $accessor = $event->getAccessor();

        foreach ($metadata->getFieldMappings() as $fieldName => $fieldMapping) {

This code seems to be duplicated across your project.

            if (false === $fieldMapping['mapped']) {
                continue;
            }

            switch ($fieldMapping['type']) {
                case 'reference':
                    $this->persistReference($node, $accessor, $fieldName, $locale, $fieldMapping);
                    break;
                default:
                    $this->persistGeneric($node, $accessor, $fieldName, $locale, $fieldMapping);
            }
        }
    }

    /**
     * Persist a reference field type.
     *
     * @param NodeInterface $node
     * @param DocumentAccessor $accessor
     * @param mixed $fieldName
     * @param mixed $locale
     * @param mixed $fieldMapping
     */
    private function persistReference(
        NodeInterface $node,
        DocumentAccessor $accessor,
        $fieldName,
        $locale,
        $fieldMapping
    ) {
        $referenceDocument = $accessor->get($fieldName);

        if (!$referenceDocument) {
            return;
        }

        if ($fieldMapping['multiple']) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Mapping references as multiple not currently supported (when mapping "%s")',
                    $fieldName
                )
            );
        }

        try {
            $referenceNode = $this->documentRegistry->getNodeForDocument($referenceDocument);
            $phpcrName = $this->encoder->encode($fieldMapping['encoding'], $fieldMapping['property'], $locale);
            $node->setProperty($phpcrName, $referenceNode);
        } catch (InvalidLocaleException $ex) {
            // arguments unvalid no valid propertyname could be generated (e.g. no locale given for localized encoding)
            return;
        }
    }

    /**
     * Persist "scalar" field types.
     *
     * @param NodeInterface $node
     * @param DocumentAccessor $accessor
     * @param mixed $fieldName
     * @param mixed $locale
     * @param array $fieldMapping
     */
    private function persistGeneric(

This method seems to be duplicated in your project.

        NodeInterface $node,
        DocumentAccessor $accessor,
        $fieldName,
        $locale,
        array $fieldMapping
    ) {
        try {
            $phpcrName = $this->encoder->encode($fieldMapping['encoding'], $fieldMapping['property'], $locale);
            $value = $accessor->get($fieldName);
            $this->validateFieldValue($value, $fieldName, $fieldMapping);
            $node->setProperty($phpcrName, $value);
        } catch (InvalidLocaleException $ex) {
            // arguments unvalid no valid propertyname could be generated (e.g. no locale given for localized encoding)
            return;
        }
    }

    /**
     * @param AbstractMappingEvent $event
     */
    public function handleHydrate(AbstractMappingEvent $event)
    {
        $class = get_class($event->getDocument());

        // TODO: Return false here in case this is for instance an UnknownDocument.
        //       But we should probably map the UnknownDocument and let an Exception be
        //       thrown in other cases.
        if (false === $this->factory->hasMetadataForClass($class)) {
            return;
        }

        $metadata = $this->factory->getMetadataForClass($class);
        $locale = $event->getLocale();
        $node = $event->getNode();
        $accessor = $event->getAccessor();
        $document = $event->getDocument();

        foreach ($metadata->getFieldMappings() as $fieldName => $fieldMapping) {

This code seems to be duplicated across your project.

            if (false === $fieldMapping['mapped']) {
                continue;
            }

            switch ($fieldMapping['type']) {
                case 'reference':
                    $this->hydrateReferenceField($node, $document, $accessor, $fieldName, $locale, $fieldMapping);
                    break;
                default:
                    $this->hydrateGenericField($node, $accessor, $fieldName, $locale, $fieldMapping);
            }
        }
    }

    /**
     * Hydrate reference field types.
     *
     * @param NodeInterface $node
     * @param mixed $document
     * @param DocumentAccessor $accessor
     * @param mixed $fieldName
     * @param mixed $locale
     * @param array $fieldMapping
     */
    private function hydrateReferenceField(

This method seems to be duplicated in your project.

        NodeInterface $node,
        $document,
        DocumentAccessor $accessor,
        $fieldName,
        $locale,
        array $fieldMapping
    ) {
        try {
            $phpcrName = $this->encoder->encode($fieldMapping['encoding'], $fieldMapping['property'], $locale);
            $referencedNode = $node->getPropertyValueWithDefault(
                $phpcrName,
                $this->getDefaultValue($fieldMapping)
            );

            if ($referencedNode) {
                $accessor->set(
                    $fieldName,
                    $this->proxyFactory->createProxyForNode($document, $referencedNode)
                );
            }
        } catch (InvalidLocaleException $ex) {
            // arguments unvalid no valid propertyname could be generated (e.g. no locale given for localized encoding)
            return;
        }
    }

    /**
     * Hydrate "scalar" field types.
     *
     * @param NodeInterface $node
     * @param DocumentAccessor $accessor
     * @param mixed $fieldName
     * @param mixed $locale
     * @param array $fieldMapping
     */
    private function hydrateGenericField(
        NodeInterface $node,
        DocumentAccessor $accessor,
        $fieldName,
        $locale,
        array $fieldMapping
    ) {
        try {
            $phpcrName = $this->encoder->encode($fieldMapping['encoding'], $fieldMapping['property'], $locale);
            $value = $node->getPropertyValueWithDefault(
                $phpcrName,
                $this->getDefaultValue($fieldMapping)
            );
            $accessor->set($fieldName, $value);
        } catch (InvalidLocaleException $ex) {
            // arguments unvalid no valid propertyname could be generated (e.g. no locale given for localized encoding)
            return;
        }
    }

    private function getDefaultValue(array $fieldMapping)
    {
        if ($fieldMapping['default']) {
            return $fieldMapping['default'];
        }

        return $fieldMapping['multiple'] ? [] : null;
    }

    private function validateFieldValue($value, $fieldName, $fieldMapping)
    {
        if ($fieldMapping['multiple'] && !is_array($value)) {

This code seems to be duplicated across your project.

            throw new \InvalidArgumentException(
                sprintf(
                    'Field "%s" is mapped as multiple, and therefore must be an array, got "%s"',
                    $fieldName,
                    is_object($value) ? get_class($value) : gettype($value)
                )
            );
        }
    }
}