Sulu\Bundle\ArticleBundle\Document\Serializer\ArticleWebsiteSubscriber

Complexity

Total Complexity

28

Size/Duplication

Total Lines	255
Duplicated Lines	21.96 %

Coupling/Cohesion

Components	1
Dependencies	15

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
B	getSubscribedEvents()	0	25	1
A	resolveContentOnPostSerialize()	0	14	3
B	appendPageData()	0	22	5
C	resolveContentForArticleOnPostSerialize()	0	25	7
A	resolveContentForArticlePageOnPostSerialize()	0	15	4
A	resolve()	0	12	1
B	createContentProxy()	28	28	3
B	createViewProxy()	28	28	3

<?php

/*
 * This file is part of Sulu.
 *
 * (c) MASSIVE ART WebServices GmbH
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Sulu\Bundle\ArticleBundle\Document\Serializer;

use JMS\Serializer\EventDispatcher\Events;
use JMS\Serializer\EventDispatcher\EventSubscriberInterface;
use JMS\Serializer\EventDispatcher\ObjectEvent;
use ProxyManager\Factory\LazyLoadingValueHolderFactory;
use ProxyManager\Proxy\LazyLoadingInterface;
use ProxyManager\Proxy\VirtualProxyInterface;
use Sulu\Bundle\ArticleBundle\Document\ArticleDocument;
use Sulu\Bundle\ArticleBundle\Document\ArticleInterface;
use Sulu\Bundle\ArticleBundle\Document\ArticlePageDocument;
use Sulu\Component\Content\Compat\StructureInterface;
use Sulu\Component\Content\Compat\StructureManagerInterface;
use Sulu\Component\Content\ContentTypeManagerInterface;

/**
 * Extends serializer with addtional functionallity to prepare article(-page) data.
 */
class ArticleWebsiteSubscriber implements EventSubscriberInterface
{
    /**
     * @var StructureManagerInterface
     */
    private $structureManager;

    /**
     * @var ContentTypeManagerInterface
     */
    private $contentTypeManager;

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

    /**
     * @param StructureManagerInterface $structureManager
     * @param ContentTypeManagerInterface $contentTypeManager
     * @param LazyLoadingValueHolderFactory $proxyFactory
     */
    public function __construct(
        StructureManagerInterface $structureManager,
        ContentTypeManagerInterface $contentTypeManager,
        LazyLoadingValueHolderFactory $proxyFactory
    ) {
        $this->structureManager = $structureManager;
        $this->contentTypeManager = $contentTypeManager;
        $this->proxyFactory = $proxyFactory;
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [
            [
                'event' => Events::POST_SERIALIZE,
                'format' => 'array',
                'method' => 'resolveContentOnPostSerialize',
            ],
            [
                'event' => Events::POST_SERIALIZE,
                'format' => 'array',
                'method' => 'resolveContentForArticleOnPostSerialize',
            ],
            [
                'event' => Events::POST_SERIALIZE,
                'format' => 'array',
                'method' => 'resolveContentForArticlePageOnPostSerialize',
            ],
            [
                'event' => Events::POST_SERIALIZE,
                'format' => 'array',
                'method' => 'appendPageData',
            ],
        ];
    }

    /**
     * Resolve content on serialization.
     *
     * @param ObjectEvent $event
     */
    public function resolveContentOnPostSerialize(ObjectEvent $event)
    {
        $article = $event->getObject();
        $visitor = $event->getVisitor();
        $context = $event->getContext();

        if (!$article instanceof ArticleInterface || !$context->attributes->containsKey('website')) {
            return;
        }

        $visitor->addData('uuid', $context->accept($article->getArticleUuid()));
        $visitor->addData('pageUuid', $context->accept($article->getPageUuid()));
        $visitor->addData('extension', $context->accept($article->getExtensionsData()->toArray()));
    }

    /**
     * Append page data.
     *
     * @param ObjectEvent $event
     */
    public function appendPageData(ObjectEvent $event)
    {
        $article = $event->getObject();
        $visitor = $event->getVisitor();
        $context = $event->getContext();

        if ($article instanceof ArticlePageDocument) {
            $article = $article->getParent();
        }

        if (!$article instanceof ArticleDocument || !$context->attributes->containsKey('website')) {
            return;
        }

        $pageNumber = 1;
        if ($context->attributes->containsKey('pageNumber')) {
            $pageNumber = $context->attributes->get('pageNumber')->get();
        }

        $visitor->addData('page', $pageNumber);
        $visitor->addData('pages', $context->accept($article->getPages()));
    }

    /**
     * Resolve content on serialization.
     *
     * @param ObjectEvent $event
     */
    public function resolveContentForArticleOnPostSerialize(ObjectEvent $event)
    {
        $article = $event->getObject();
        $visitor = $event->getVisitor();
        $context = $event->getContext();

        if (!$article instanceof ArticleDocument || !$context->attributes->containsKey('website')) {
            return;
        }

        $children = $article->getChildren();

        if (null !== $children && $context->attributes->containsKey('pageNumber')) {
            $pages = array_values(iterator_to_array($children));
            $pageNumber = $context->attributes->get('pageNumber')->get();
            if ($pageNumber !== 1) {
                $article = $pages[$pageNumber - 2];
            }
        }

        $content = $this->resolve($article);
        foreach ($content as $name => $value) {
            $visitor->addData($name, $value);
        }
    }

    /**
     * Resolve content on serialization.
     *
     * @param ObjectEvent $event
     */
    public function resolveContentForArticlePageOnPostSerialize(ObjectEvent $event)
    {
        $article = $event->getObject();
        $visitor = $event->getVisitor();
        $context = $event->getContext();

        if (!$article instanceof ArticlePageDocument || !$context->attributes->containsKey('website')) {
            return;
        }

        $content = $this->resolve($article);
        foreach ($content as $name => $value) {
            $visitor->addData($name, $value);
        }
    }

    /**
     * Returns content and view of article.
     *
     * @param ArticleInterface $article
     *
     * @return array
     */
    private function resolve(ArticleInterface $article)
    {
        $structure = $this->structureManager->getStructure($article->getStructureType(), 'article');
        $structure->setDocument($article);

        $data = $article->getStructure()->toArray();

        return [
            'content' => $this->createContentProxy($structure, $data),
            'view' => $this->createViewProxy($structure, $data),
        ];
    }

    /**
     * Create content-proxy for given structure.
     *
     * @param StructureInterface $structure
     * @param array $data
     *
     * @return VirtualProxyInterface
     */
    private function createContentProxy($structure, $data)

This method seems to be duplicated in your project.

    {
        return $this->proxyFactory->createProxy(
            \ArrayObject::class,
            function (
                &$wrappedObject,
                LazyLoadingInterface $proxy,
                $method,
                array $parameters,
                &$initializer
            ) use ($structure, $data) {
                $content = [];
                foreach ($structure->getProperties(true) as $child) {
                    if (array_key_exists($child->getName(), $data)) {
                        $child->setValue($data[$child->getName()]);
                    }

                    $contentType = $this->contentTypeManager->get($child->getContentTypeName());
                    $content[$child->getName()] = $contentType->getContentData($child);
                }

                $initializer = null;
                $wrappedObject = new \ArrayObject($content);

                return true;
            }
        );
    }

    /**
     * Create view-proxy for given structure.
     *
     * @param StructureInterface $structure
     * @param array $data
     *
     * @return VirtualProxyInterface
     */
    private function createViewProxy($structure, array $data)

This method seems to be duplicated in your project.

    {
        return $this->proxyFactory->createProxy(
            \ArrayObject::class,
            function (
                &$wrappedObject,
                LazyLoadingInterface $proxy,
                $method,
                array $parameters,
                &$initializer
            ) use ($structure, $data) {
                $view = [];
                foreach ($structure->getProperties(true) as $child) {
                    if (array_key_exists($child->getName(), $data)) {
                        $child->setValue($data[$child->getName()]);
                    }

                    $contentType = $this->contentTypeManager->get($child->getContentTypeName());
                    $view[$child->getName()] = $contentType->getViewData($child);
                }

                $initializer = null;
                $wrappedObject = new \ArrayObject($view);

                return true;
            }
        );
    }
}