Victoire\Bundle\WidgetBundle\Model\WidgetManager

Complexity

Total Complexity

25

Size/Duplication

Total Lines	368
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	20

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	33	1
B	newWidget()	0	31	1
B	createWidget()	0	63	6
C	editWidget()	0	77	7
B	deleteWidget()	0	26	3
A	overwriteWidget()	0	8	1
B	cloneEntity()	0	35	6

<?php

namespace Victoire\Bundle\WidgetBundle\Model;

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use Symfony\Bundle\FrameworkBundle\Templating\EngineInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Victoire\Bundle\BusinessEntityBundle\Entity\BusinessEntity;
use Victoire\Bundle\BusinessEntityBundle\Helper\BusinessEntityHelper;
use Victoire\Bundle\BusinessPageBundle\Entity\VirtualBusinessPage;
use Victoire\Bundle\BusinessPageBundle\Transformer\VirtualToBusinessPageTransformer;
use Victoire\Bundle\CoreBundle\Entity\View;
use Victoire\Bundle\CoreBundle\Event\WidgetFlushedEvent;
use Victoire\Bundle\CoreBundle\VictoireCmsEvents;
use Victoire\Bundle\FormBundle\Helper\FormErrorHelper;
use Victoire\Bundle\PageBundle\Helper\PageHelper;
use Victoire\Bundle\WidgetBundle\Builder\WidgetFormBuilder;
use Victoire\Bundle\WidgetBundle\Helper\WidgetHelper;
use Victoire\Bundle\WidgetBundle\Renderer\WidgetRenderer;
use Victoire\Bundle\WidgetBundle\Resolver\WidgetContentResolver;
use Victoire\Bundle\WidgetMapBundle\Builder\WidgetMapBuilder;
use Victoire\Bundle\WidgetMapBundle\Entity\WidgetMap;
use Victoire\Bundle\WidgetMapBundle\Helper\WidgetMapHelper;
use Victoire\Bundle\WidgetMapBundle\Manager\WidgetMapManager;

/**
 * This manager handles crud operations on a Widget.
 */
class WidgetManager
{
    protected $widgetFormBuilder;
    protected $widgetHelper;
    protected $widgetContentResolver;
    protected $widgetRenderer;
    protected $eventDispatcher;
    protected $entityManager;
    protected $formErrorHelper; // @victoire_form.error_helper
    protected $request; // @request
    protected $widgetMapManager;
    protected $businessEntityHelper;
    protected $templating;
    protected $pageHelper;
    protected $slots; // %victoire_core.slots%
    protected $virtualToBpTransformer;

    /**

Doc comment for parameter "$eventDispatcher" missing

Doc comment for parameter "$businessEntityHelper" missing

Doc comment for parameter "$virtualToBpTransformer" missing

     * construct.
     *
     * @param WidgetHelper              $widgetHelper

Expected 13 spaces after parameter type; 14 found

     * @param WidgetFormBuilder         $widgetFormBuilder

Expected 8 spaces after parameter type; 9 found

     * @param WidgetContentResolver     $widgetContentResolver

Expected 4 spaces after parameter type; 5 found

     * @param WidgetRenderer            $widgetRenderer

Expected 11 spaces after parameter type; 12 found

     * @param EventDispatcherInterface  $eventDispatcher,

There is no parameter named $eventDispatcher,. Did you maybe mean $eventDispatcher?

Expected 1 spaces after parameter type; 2 found

Doc comment for parameter $eventDispatcher, does not match actual variable name $eventDispatcher

     * @param EntityManager             $entityManager

Expected 12 spaces after parameter type; 13 found

     * @param FormErrorHelper           $formErrorHelper

Expected 10 spaces after parameter type; 11 found

     * @param Request                   $request

Expected 18 spaces after parameter type; 19 found

     * @param WidgetMapManager          $widgetMapManager

Expected 9 spaces after parameter type; 10 found

     * @param WidgetMapBuilder          $widgetMapBuilder

Expected 9 spaces after parameter type; 10 found

     * @param EngineInterface           $templating

Doc comment for parameter $templating does not match actual variable name $businessEntityHelper

Expected 10 spaces after parameter type; 11 found

     * @param PageHelper                $pageHelper

Doc comment for parameter $pageHelper does not match actual variable name $templating

Expected 15 spaces after parameter type; 16 found

     * @param array                     $slots

Doc comment for parameter $slots does not match actual variable name $pageHelper

Expected 20 spaces after parameter type; 21 found

     */
    public function __construct(
        WidgetHelper $widgetHelper,
        WidgetFormBuilder $widgetFormBuilder,
        WidgetContentResolver $widgetContentResolver,
        WidgetRenderer $widgetRenderer,
        EventDispatcherInterface $eventDispatcher,
        EntityManager $entityManager,

You have injected the EntityManager via parameter $entityManager. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via getManager() each time you need it.

        FormErrorHelper $formErrorHelper,
        Request $request,

You have injected the Request via parameter $request. This is generally not recommended as there might be multiple instances during a request cycle (f.e. when using sub-requests). Instead, it is recommended to inject the RequestStack and retrieve the current request each time you need it via getCurrentRequest().

        WidgetMapManager $widgetMapManager,
        WidgetMapBuilder $widgetMapBuilder,
        BusinessEntityHelper $businessEntityHelper,
        EngineInterface $templating,
        PageHelper $pageHelper,
        $slots,
        VirtualToBusinessPageTransformer $virtualToBpTransformer
    ) {
        $this->widgetFormBuilder = $widgetFormBuilder;
        $this->widgetHelper = $widgetHelper;
        $this->widgetContentResolver = $widgetContentResolver;
        $this->widgetRenderer = $widgetRenderer;
        $this->eventDispatcher = $eventDispatcher;
        $this->entityManager = $entityManager;
        $this->formErrorHelper = $formErrorHelper;
        $this->request = $request;
        $this->widgetMapManager = $widgetMapManager;
        $this->widgetMapBuilder = $widgetMapBuilder;

The property widgetMapBuilder does not exist. Did you maybe forget to declare it?

        $this->businessEntityHelper = $businessEntityHelper;
        $this->templating = $templating;
        $this->pageHelper = $pageHelper;
        $this->slots = $slots;
        $this->virtualToBpTransformer = $virtualToBpTransformer;
    }

    /**

Doc comment for parameter "$mode" missing

Doc comment for parameter "$parentWidgetMap" missing

Doc comment for parameter "$quantum" missing

     * new widget.
     *
     * @param string $type

Doc comment for parameter $type does not match actual variable name $mode

     * @param string $slot

Doc comment for parameter $slot does not match actual variable name $type

     * @param View   $view

Doc comment for parameter $view does not match actual variable name $slot

     * @param int    $position

Doc comment for parameter $position does not match actual variable name $view

     *
     * @return array
     */
    public function newWidget($mode, $type, $slot, $view, $position, $parentWidgetMap, $quantum)
    {
        $quantum = $this->widgetFormBuilder->convertToString($quantum);

        $widget = $this->widgetHelper->newWidgetInstance($type, $mode);
        $widgets = [$widget];

        /** @var BusinessEntity[] $classes */
        $classes = $this->businessEntityHelper->getAvailableForWidget($this->widgetHelper->getWidgetName($widget));

        $forms = $this->widgetFormBuilder->renderNewQuantumForms($slot, $view, $widgets, $widget, $classes, $position, $parentWidgetMap, $quantum);

$widgets is of type array<integer,object<Victoire\Bundle\WidgetBundle\Entity\Widget>,{"0":"object<Victoire\\Bundle\\WidgetBundle\\Entity\\Widget>"}>, but the function expects a object<Victoire\Bundle\WidgetBundle\Entity\Widget>.

        return [
            'widget' => $widget,
            'html'   => $this->templating->render(
                'VictoireCoreBundle:Widget:Form/new.html.twig',
                [
                    'id'                 => time(),
                    'view'               => $view,
                    'slot'               => $slot,
                    'position'           => $position,
                    'parentWidgetMap'    => $parentWidgetMap,
                    'classes'            => $classes,
                    'widgets'            => $widgets,
                    'widget'             => $widget,
                    'forms'              => $forms,
                    'quantum'            => $quantum,
                ]
            ),
        ];
    }

    /**

Doc comment for parameter "$position" missing

Doc comment for parameter "$widgetReference" missing

Doc comment for parameter "$quantum" missing

     * Create a widget.
     *
     * @param string $mode
     * @param string $type
     * @param string $slotId
     * @param View   $view
     * @param string $entity
     * @param string $type

Doc comment for parameter $type does not match actual variable name $position

     *
     * @throws \Exception
     *
     * @return Template
     */
    public function createWidget($mode, $type, $slotId, View $view, $entity, $position, $widgetReference, $quantum)
    {
        //services
        $formErrorHelper = $this->formErrorHelper;
        $request = $this->request;

        if ($view instanceof VirtualBusinessPage) {
            $this->virtualToBpTransformer->transform($view);
        }
        //create a new widget
        $widget = $this->widgetHelper->newWidgetInstance($type, $mode);

        $businessEntity = $this->entityManager->getRepository('VictoireBusinessEntityBundle:BusinessEntity')->findOneBy(['name' => $entity]);
        $form = $this->widgetFormBuilder->callBuildFormSwitchParameters($widget, $view, $businessEntity, $position, $widgetReference, $slotId, $quantum);

$businessEntity is of type object|null, but the function expects a object<Victoire\Bundle\BusinessEntityBundle\Entity\BusinessEntity>.

        $noValidate = $request->query->get('novalidate', false);

        $form->handleRequest($request);
        if ($noValidate === false && $form->isValid()) {
            if (!$view->getId()) {
                //create a view for the business entity instance if we are currently on a virtual one
                $this->entityManager->persist($view);
            }

            //get the widget from the form
            $widget = $form->getData();

            //persist the widget
            $this->entityManager->persist($widget);
            $this->entityManager->flush();

            $this->widgetMapManager->insert($widget, $view, $slotId, $position, $widgetReference);

            $this->entityManager->persist($view);
            $this->entityManager->flush();

            $widget->setCurrentView($view);

            $event = new WidgetFlushedEvent($widget);
            $this->eventDispatcher->dispatch(VictoireCmsEvents::WIDGET_POST_FLUSH, $event);
            $this->eventDispatcher->dispatch(VictoireCmsEvents::WIDGET_POST_FLUSH.'_'.strtoupper($type), $event);

            $this->widgetMapBuilder->build($view);

            //get the html for the widget
            $htmlWidget = $this->widgetRenderer->renderContainer($widget, $view);

            $response = [
                'success'  => true,
                'widgetId' => $widget->getId(),
                'html'     => $htmlWidget,
            ];
        } else {
            //get the errors as a string
            $response = [
                'success' => false,
                'message' => $noValidate === false ? $formErrorHelper->getRecursiveReadableErrors($form) : null,
                'html'    => $this->widgetFormBuilder->renderNewForm($form, $widget, $slotId, $view, $quantum, $entity),
            ];
        }

        return $response;
    }

    /**

Doc comment for parameter "$quantum" missing

Doc comment for parameter "$widgetMode" missing

     * edit a widget.
     *
     * @param Request $request
     * @param Widget  $widget
     * @param View    $currentView
     * @param string  $businessEntityName The entity name is used to know which form to submit

Doc comment for parameter $businessEntityName does not match actual variable name $quantum

     *
     * @return template
     */
    public function editWidget(Request $request, Widget $widget, View $currentView, $quantum = null, $businessEntityName = null, $widgetMode = Widget::MODE_STATIC)
    {
        /** @var BusinessEntity[] $classes */
        $classes = $this->businessEntityHelper->getAvailableForWidget($this->widgetHelper->getWidgetName($widget));

$widget of type object<Victoire\Bundle\WidgetBundle\Model\Widget> is not a sub-type of object<Victoire\Bundle\WidgetBundle\Entity\Widget>. It seems like you assume a child class of the class Victoire\Bundle\WidgetBundle\Model\Widget to be always present.

        //the id of the edited widget
        //a new widget might be created in the case of a legacy
        $initialWidgetId = $widget->getId();

        //the type of method used
        $requestMethod = $request->getMethod();

        //if the form is posted
        if ($requestMethod === 'POST') {
            //the widget view
            $widgetView = $widget->getWidgetMap()->getView();

            //we only copy the widget if the view of the widget is not the current view
            if ($widgetView !== $currentView) {
                $widget = $this->overwriteWidget($currentView, $widget);
            }
            $form = $this->widgetFormBuilder->buildForm($widget, $currentView, $businessEntityName, $widgetMode, null, null, null, $quantum);

$widget of type object<Victoire\Bundle\WidgetBundle\Model\Widget> is not a sub-type of object<Victoire\Bundle\WidgetBundle\Entity\Widget>. It seems like you assume a child class of the class Victoire\Bundle\WidgetBundle\Model\Widget to be always present.

            $noValidate = $request->query->get('novalidate', false);
            $form->handleRequest($request);
            if ($noValidate === false && $form->isValid()) {

Blank line found at start of control structure

                //force cache invalidation
                $widget->setUpdatedAt(new \DateTime());
                $this->entityManager->persist($widget);

                $this->entityManager->persist($currentView);
                $this->entityManager->flush();

                $response = [
                    'view'        => $currentView,
                    'success'     => true,
                    'html'        => $this->widgetRenderer->render($widget, $currentView),

$widget of type object<Victoire\Bundle\WidgetBundle\Model\Widget> is not a sub-type of object<Victoire\Bundle\WidgetBundle\Entity\Widget>. It seems like you assume a child class of the class Victoire\Bundle\WidgetBundle\Model\Widget to be always present.

                    'widgetId'    => $initialWidgetId,
                    'slot'        => $widget->getWidgetMap()->getSlot(),
                    'viewCssHash' => $currentView->getCssHash(),
                ];
            } else {
                $formErrorHelper = $this->formErrorHelper;
                //Return a message for developer in console and form view in order to refresh view and show form errors
                $response = [
                    'success'     => false,
                    'widgetId'    => $initialWidgetId,
                    'slot'        => $widget->getWidgetMap()->getSlot(),
                    'message'     => $noValidate === false ? $formErrorHelper->getRecursiveReadableErrors($form) : null,
                    'html'        => $this->widgetFormBuilder->renderForm($form, $widget, $businessEntityName),

$widget of type object<Victoire\Bundle\WidgetBundle\Model\Widget> is not a sub-type of object<Victoire\Bundle\WidgetBundle\Entity\Widget>. It seems like you assume a child class of the class Victoire\Bundle\WidgetBundle\Model\Widget to be always present.

It seems like $businessEntityName defined by parameter $businessEntityName on line 231 can also be of type string; however, Victoire\Bundle\WidgetBundle\Builder\WidgetFormBuilder::renderForm() does only seem to accept object|null, maybe add an additional type check?

                ];
            }
        } else {
            $widgets = $widget->getWidgetMap()->getWidgets();
            $forms = $this->widgetFormBuilder->renderNewQuantumForms($widget->getSlot(), $currentView, $widgets, $widget, $classes);

            $response = [
                'success'  => true,
                'html'     => $this->templating->render(
                    'VictoireCoreBundle:Widget:Form/edit.html.twig',
                    [
                        'view'               => $currentView,
                        'slot'               => $widget->getWidgetMap()->getSlot(),
                        'position'           => $widget->getWidgetMap()->getPosition(),
                        'parentWidgetMap'    => $widget->getWidgetMap()->getParent() ? $widget->getWidgetMap()->getParent()->getId() : null,
                        'classes'            => $classes,
                        'forms'              => $forms,
                        'widgets'            => $widgets,
                        'widget'             => $widget,
                    ]
                ),
            ];
        }

        return $response;
    }

    /**

Doc comment for parameter "$view" missing

     * Remove a widget.
     *
     * @param Widget $widget
     *
     * @return array The parameter for the view
     */
    public function deleteWidget(Widget $widget, View $view)
    {
        //Used to update view in callback (we do it before delete it else it'll not exists anymore)
        $widgetId = $widget->getId();
        //we update the widget map of the view
        $this->widgetMapBuilder->build($view);
        $widgetMap = WidgetMapHelper::getWidgetMapByWidgetAndView($widget, $view);

$widget of type object<Victoire\Bundle\WidgetBundle\Model\Widget> is not a sub-type of object<Victoire\Bundle\WidgetBundle\Entity\Widget>. It seems like you assume a child class of the class Victoire\Bundle\WidgetBundle\Model\Widget to be always present.

        //the widget is removed only if the current view is the view of the widget
        if ($widgetMap->getView() == $view && $widgetMap->getAction() != WidgetMap::ACTION_DELETE) {

The method getView does only exist in Victoire\Bundle\WidgetMapBundle\Entity\WidgetMap, but not in Victoire\Bundle\WidgetMapBundle\Exception\WidgetMapNotFoundException.

The method getAction does only exist in Victoire\Bundle\WidgetMapBundle\Entity\WidgetMap, but not in Victoire\Bundle\WidgetMapBundle\Exception\WidgetMapNotFoundException.

            //we remove the widget
            $this->entityManager->remove($widget);
        }

        //we update the view
        $this->entityManager->persist($view);
        //update the view deleting the widget
        $this->widgetMapManager->delete($view, $widget);

$widget of type object<Victoire\Bundle\WidgetBundle\Model\Widget> is not a sub-type of object<Victoire\Bundle\WidgetBundle\Entity\Widget>. It seems like you assume a child class of the class Victoire\Bundle\WidgetBundle\Model\Widget to be always present.

        $this->entityManager->flush();

        return [
            'success'     => true,
            'widgetId'    => $widgetId,
            'viewCssHash' => $view->getCssHash(),
        ];
    }

    /**
     * Overwrite the widget for the current view because the widget is not linked to the current view, a copy is created.
     *
     * @param View   $view
     * @param Widget $widget
     *
     * @throws \Exception The slot does not exists
     *
     * @return Widget The widget
     */
    public function overwriteWidget(View $view, Widget $widget)
    {
        $widgetCopy = $this->cloneEntity($widget);

The expression $this->cloneEntity($widget); of type object|array adds the type array to the return on line 359 which is incompatible with the return type documented by Victoire\Bundle\WidgetBundle\Model\WidgetManager::overwriteWidget of type Victoire\Bundle\WidgetBundle\Model\Widget.

        $originalWidgetMap = $widget->getWidgetMap();
        $this->widgetMapManager->overwrite($view, $originalWidgetMap, $widgetCopy);

$widgetCopy is of type object|array, but the function expects a object<Victoire\Bundle\WidgetBundle\Entity\Widget>.

        return $widgetCopy;
    }

    /**
     * @param Widget $entity
     */

Missing @return tag in function comment

    public function cloneEntity(Widget $entity)
    {
        $entityCopy = clone $entity;
        $entityCopy->setWidgetMap(null);
        //Look for on_to_many relations, if found, duplicate related entities.
        //It is necessary for 'list' widgets, this algo duplicates and persists list items.
        $associations = $this->entityManager->getClassMetadata(get_class($entityCopy))->getAssociationMappings();
        $accessor = PropertyAccess::createPropertyAccessor();
        foreach ($associations as $name => $values) {
            if ($values['type'] === ClassMetadataInfo::ONE_TO_MANY) {
                $relatedEntities = $accessor->getValue($entityCopy, $values['fieldName']);
                $relatedEntitiesCopies = [];
                foreach ($relatedEntities as $relatedEntity) {
                    $relatedEntityCopy = clone $relatedEntity;
                    $this->entityManager->persist($relatedEntity);
                    $relatedEntitiesCopies[] = $relatedEntityCopy;
                }
                $accessor->setValue($entityCopy, $name, $relatedEntitiesCopies);
            }

            //Clone OneToOne relation objects
            if ($values['type'] === ClassMetadataInfo::ONE_TO_ONE) {
                $relatedEntity = $accessor->getValue($entityCopy, $values['fieldName']);
                if ($relatedEntity) {
                    $relatedEntityCopy = clone $relatedEntity;
                    $this->entityManager->persist($relatedEntity);
                    $accessor->setValue($entityCopy, $name, $relatedEntityCopy);
                }
            }
        }

        $this->entityManager->persist($entityCopy);

It seems like $entityCopy can also be of type array; however, Doctrine\ORM\EntityManager::persist() does only seem to accept object, maybe add an additional type check?

        return $entityCopy;
    }
}