SWP\Bundle\TemplateEngineBundle\Service\ContainerService

Complexity

Total Complexity

19

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

88.57%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
B	getContainer()	0	35	6
A	getRenderer()	0	20	3
D	createNewContainer()	0	38	9

<?php

/**
 * This file is part of the Superdesk Web Publisher Template Engine Bundle.
 *
 * Copyright 2015 Sourcefabric z.u. and contributors.
 *
 * For the full copyright and license information, please see the
 * AUTHORS and LICENSE files distributed with this source code.
 *
 * @copyright 2015 Sourcefabric z.ú
 * @license http://www.superdesk.org/license
 */

namespace SWP\Bundle\TemplateEngineBundle\Service;

use SWP\Bundle\TemplateEngineBundle\Container\SimpleContainer;
use SWP\Bundle\TemplateEngineBundle\Model\Container;
use SWP\Bundle\TemplateEngineBundle\Model\ContainerData;
use SWP\Component\Common\Event\HttpCacheEvent;
use Symfony\Bridge\Doctrine\RegistryInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

class ContainerService
{
    const OPEN_TAG_TEMPLATE = '<div id="swp_container_{{ id }}" class="swp_container {{ class }}" style="{% if height %}height: {{ height }}px;{% endif %}{% if width %}width: {{width}}px;{% endif %}{{styles}}"{% for value in data %} data-{{value.getKey()}}="{{value.getValue()}}"{% endfor %} >';
    const CLOSE_TAG_TEMPLATE = '</div>';

    protected $serviceContainer;
    protected $objectManager;
    protected $cacheDir;
    protected $debug;
    protected $renderer = false;
    protected $eventDispatcher;

    /**
     * ContainerService constructor.
     *
     * @param RegistryInterface        $registry
     * @param EventDispatcherInterface $eventDispatcher
     * @param ContainerInterface       $serviceContainer
     * @param string                   $cacheDir
     * @param bool                     $debug
     */
    public function __construct(RegistryInterface $registry, EventDispatcherInterface $eventDispatcher, ContainerInterface $serviceContainer, $cacheDir, $debug = false)
    {
        $this->objectManager = $registry->getEntityManager();
        $this->cacheDir = $cacheDir.'/twig';
        $this->debug = $debug;
        $this->eventDispatcher = $eventDispatcher;
        $this->serviceContainer = $serviceContainer;
    }

    public function getContainer($name, array $parameters = [], $createIfNotExists = true)
    {
        $containerEntity = $this->objectManager->getRepository('SWP\Bundle\TemplateEngineBundle\Model\Container')
            ->getByName($name)
            ->getOneOrNullResult();

        if (!$containerEntity && $createIfNotExists) {
            $containerEntity = $this->createNewContainer($name, $parameters);
        } elseif (!$containerEntity) {
            throw new \Exception('Container was not found');
        }

        $widgets = [];
        $containerWidgets = $this->objectManager->getRepository('SWP\Bundle\TemplateEngineBundle\Model\ContainerWidget')
            ->getSortedWidgets(['container' => $containerEntity])
            ->getResult();

        foreach ($containerWidgets as $containerWidget) {
            $widgetModel = $containerWidget->getWidget();
            $widgetClass = $widgetModel->getType();

            if (is_a($widgetClass, '\SWP\Bundle\TemplateEngineBundle\Widget\TemplatingWidgetHandler', true)) {
                $widgetHandler = new $widgetClass($widgetModel, $this->serviceContainer->get('templating'));
            } else {
                $widgetHandler = new $widgetClass($widgetModel);
            }

            $widgets[] = $widgetHandler;
        }

        $container = new SimpleContainer($containerEntity, $this->getRenderer());

It seems like $this->getRenderer() targeting SWP\Bundle\TemplateEngineBundle\Service\ContainerService::getRenderer() can also be of type boolean; however, SWP\Bundle\TemplateEngineBundle\Container\SimpleContainer::__construct() does only seem to accept object<Twig_Environment>, maybe add an additional type check?

        $container->setWidgets($widgets);

        return $container;
    }

    public function getRenderer()
    {
        if ($this->renderer !== false) {
            return $this->renderer;
        }

        $options = [];
        if (false === $this->debug) {
            $options['cache'] = $this->cacheDir;
        }

        $this->renderer = new \Twig_Environment(

It seems like new \Twig_Environment(new \Twig_Loader_Array(array('open_tag' => self::OPEN_TAG_TEMPLATE, 'close_tag' => self::CLOSE_TAG_TEMPLATE)), $options) of type object<Twig_Environment> is incompatible with the declared type boolean of property $renderer.

            new \Twig_Loader_Array([
                'open_tag' => self::OPEN_TAG_TEMPLATE,
                'close_tag' => self::CLOSE_TAG_TEMPLATE,
            ]), $options
        );

        return $this->renderer;
    }

    public function createNewContainer($name, array $parameters = [])
    {
        $containerEntity = new Container();
        $containerEntity->setName($name);
        foreach ($parameters as $key => $value) {
            switch ($key) {
                case 'height':
                    $containerEntity->setHeight($value);
                    break;
                case 'width':
                    $containerEntity->setWidth($value);
                    break;
                case 'cssClass':
                    $containerEntity->setCssClass($value);
                    break;
                case 'styles':
                    $containerEntity->setStyles($value);
                    break;
                case 'visible':
                    $containerEntity->setVisible($value);
                    break;
                case 'data':
                    foreach ($value as $dataKey => $dataValue) {
                        $containerData = new ContainerData($dataKey, $dataValue);
                        $containerData->setContainer($containerEntity);
                        $this->objectManager->persist($containerData);
                        $containerEntity->addData($containerData);
                    }
            }
        }
        $this->objectManager->persist($containerEntity);
        $this->objectManager->flush();

        $this->eventDispatcher
            ->dispatch(HttpCacheEvent::EVENT_NAME, new HttpCacheEvent($containerEntity));

        return $containerEntity;
    }
}