Kunstmaan\NodeBundle\Helper\NodeAdmin\NodeAdminPublisher

Complexity

Total Complexity

22

Size/Duplication

Total Lines	315
Duplicated Lines	33.02 %

Coupling/Cohesion

Components	1
Dependencies	17

Test Coverage

Coverage

0%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	13	13	1
A	publish()	0	43	4
A	publishLater()	20	20	2
A	unPublish()	0	26	2
A	unPublishLater()	19	19	2
A	unSchedulePublish()	0	11	2
A	createPublicVersion()	0	35	1
A	chooseHowToPublish()	22	22	3
A	chooseHowToUnpublish()	20	20	3
A	dispatch()	10	10	2

<?php

namespace Kunstmaan\NodeBundle\Helper\NodeAdmin;

use Doctrine\ORM\EntityManager;
use Kunstmaan\AdminBundle\Entity\BaseUser;
use Kunstmaan\AdminBundle\Helper\CloneHelper;
use Kunstmaan\AdminBundle\Helper\Security\Acl\Permission\PermissionMap;
use Kunstmaan\NodeBundle\Entity\HasNodeInterface;
use Kunstmaan\NodeBundle\Entity\Node;
use Kunstmaan\NodeBundle\Entity\NodeTranslation;
use Kunstmaan\NodeBundle\Entity\NodeVersion;
use Kunstmaan\NodeBundle\Entity\QueuedNodeTranslationAction;
use Kunstmaan\NodeBundle\Event\Events;
use Kunstmaan\NodeBundle\Event\NodeEvent;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\LegacyEventDispatcherProxy;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\Translation\TranslatorInterface;
use Kunstmaan\AdminBundle\FlashMessages\FlashTypes;

class NodeAdminPublisher
{
    /**
     * @var EntityManager
     */
    private $em;

    /**
     * @var TokenStorageInterface
     */
    private $tokenStorage;

    /**
     * @var AuthorizationCheckerInterface
     */
    private $authorizationChecker;

    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    /**
     * @var CloneHelper
     */
    private $cloneHelper;

    /**
     * @param EntityManager                 $em                   The entity manager
     * @param TokenStorageInterface         $tokenStorage         The security token storage
     * @param AuthorizationCheckerInterface $authorizationChecker The security authorization checker
     * @param EventDispatcherInterface      $eventDispatcher      The Event dispatcher
     * @param CloneHelper                   $cloneHelper          The clone helper
     */
    public function __construct(

This method seems to be duplicated in your project.

        EntityManager $em,

You have injected the EntityManager via parameter $em. 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.

        TokenStorageInterface $tokenStorage,
        AuthorizationCheckerInterface $authorizationChecker,
        EventDispatcherInterface $eventDispatcher,
        CloneHelper $cloneHelper
    ) {
        $this->em = $em;
        $this->tokenStorage = $tokenStorage;
        $this->authorizationChecker = $authorizationChecker;
        $this->eventDispatcher = $eventDispatcher;
        $this->cloneHelper = $cloneHelper;
    }

    /**
     * If there is a draft version it'll try to publish the draft first. Makse snese because if you want to publish the public version you don't publish but you save.
     *
     * @param NodeTranslation $nodeTranslation
     * @param BaseUser|null   $user
     *
     *  @throws AccessDeniedException
     */
    public function publish(NodeTranslation $nodeTranslation, $user = null)
    {
        if (false === $this->authorizationChecker->isGranted(PermissionMap::PERMISSION_PUBLISH, $nodeTranslation->getNode())) {
            throw new AccessDeniedException();
        }

        if (\is_null($user)) {
            $user = $this->tokenStorage->getToken()->getUser();
        }

        $node = $nodeTranslation->getNode();

        $nodeVersion = $nodeTranslation->getNodeVersion('draft');
        if (!\is_null($nodeVersion)) {
            $page = $nodeVersion->getRef($this->em);
            /** @var NodeVersion $nodeVersion */
            $nodeVersion = $this->createPublicVersion($page, $nodeTranslation, $nodeVersion, $user);

It seems like $page defined by $nodeVersion->getRef($this->em) on line 96 can be null; however, Kunstmaan\NodeBundle\Helper\NodeAdmin\NodeAdminPublisher::createPublicVersion() does not accept null, maybe add an additional type check?

            $nodeTranslation = $nodeVersion->getNodeTranslation();
        } else {
            $nodeVersion = $nodeTranslation->getPublicNodeVersion();
        }

        $page = $nodeVersion->getRef($this->em);

        $this->dispatch(
            new NodeEvent($node, $nodeTranslation, $nodeVersion, $page),

It seems like $page defined by $nodeVersion->getRef($this->em) on line 104 can be null; however, Kunstmaan\NodeBundle\Event\NodeEvent::__construct() does not accept null, maybe add an additional type check?

            Events::PRE_PUBLISH
        );
        $nodeTranslation
            ->setOnline(true)
            ->setPublicNodeVersion($nodeVersion)
            ->setUpdated(new \DateTime());
        $this->em->persist($nodeTranslation);
        $this->em->flush();

        // Remove scheduled task
        $this->unSchedulePublish($nodeTranslation);

        $this->dispatch(
            new NodeEvent($node, $nodeTranslation, $nodeVersion, $page),

It seems like $page defined by $nodeVersion->getRef($this->em) on line 104 can be null; however, Kunstmaan\NodeBundle\Event\NodeEvent::__construct() does not accept null, maybe add an additional type check?

            Events::POST_PUBLISH
        );
    }

    /**
     * @param NodeTranslation $nodeTranslation The NodeTranslation
     * @param \DateTime       $date            The date to publish
     *
     * @throws AccessDeniedException
     */
    public function publishLater(NodeTranslation $nodeTranslation, \DateTime $date)

This method seems to be duplicated in your project.

    {
        $node = $nodeTranslation->getNode();
        if (false === $this->authorizationChecker->isGranted(PermissionMap::PERMISSION_PUBLISH, $node)) {
            throw new AccessDeniedException();
        }

        //remove existing first
        $this->unSchedulePublish($nodeTranslation);

        $user = $this->tokenStorage->getToken()->getUser();
        $queuedNodeTranslationAction = new QueuedNodeTranslationAction();
        $queuedNodeTranslationAction
            ->setNodeTranslation($nodeTranslation)
            ->setAction(QueuedNodeTranslationAction::ACTION_PUBLISH)
            ->setUser($user)
            ->setDate($date);
        $this->em->persist($queuedNodeTranslationAction);
        $this->em->flush();
    }

    /**
     * @param NodeTranslation $nodeTranslation
     *
     * @throws AccessDeniedException
     */
    public function unPublish(NodeTranslation $nodeTranslation)
    {
        if (false === $this->authorizationChecker->isGranted(PermissionMap::PERMISSION_UNPUBLISH, $nodeTranslation->getNode())) {
            throw new AccessDeniedException();
        }

        $node = $nodeTranslation->getNode();
        $nodeVersion = $nodeTranslation->getPublicNodeVersion();
        $page = $nodeVersion->getRef($this->em);

        $this->dispatch(
            new NodeEvent($node, $nodeTranslation, $nodeVersion, $page),

It seems like $page defined by $nodeVersion->getRef($this->em) on line 166 can be null; however, Kunstmaan\NodeBundle\Event\NodeEvent::__construct() does not accept null, maybe add an additional type check?

            Events::PRE_UNPUBLISH
        );
        $nodeTranslation->setOnline(false);
        $this->em->persist($nodeTranslation);
        $this->em->flush();

        // Remove scheduled task
        $this->unSchedulePublish($nodeTranslation);

        $this->dispatch(
            new NodeEvent($node, $nodeTranslation, $nodeVersion, $page),

It seems like $page defined by $nodeVersion->getRef($this->em) on line 166 can be null; however, Kunstmaan\NodeBundle\Event\NodeEvent::__construct() does not accept null, maybe add an additional type check?

            Events::POST_UNPUBLISH
        );
    }

    /**
     * @param NodeTranslation $nodeTranslation The NodeTranslation
     * @param \DateTime       $date            The date to unpublish
     *
     * @throws AccessDeniedException
     */
    public function unPublishLater(NodeTranslation $nodeTranslation, \DateTime $date)

This method seems to be duplicated in your project.

    {
        $node = $nodeTranslation->getNode();
        if (false === $this->authorizationChecker->isGranted(PermissionMap::PERMISSION_UNPUBLISH, $node)) {
            throw new AccessDeniedException();
        }

        //remove existing first
        $this->unSchedulePublish($nodeTranslation);
        $user = $this->tokenStorage->getToken()->getUser();
        $queuedNodeTranslationAction = new QueuedNodeTranslationAction();
        $queuedNodeTranslationAction
            ->setNodeTranslation($nodeTranslation)
            ->setAction(QueuedNodeTranslationAction::ACTION_UNPUBLISH)
            ->setUser($user)
            ->setDate($date);
        $this->em->persist($queuedNodeTranslationAction);
        $this->em->flush();
    }

    /**
     * @param NodeTranslation $nodeTranslation
     */
    public function unSchedulePublish(NodeTranslation $nodeTranslation)
    {
        /* @var Node $node */
        $queuedNodeTranslationAction = $this->em->getRepository(QueuedNodeTranslationAction::class)
            ->findOneBy(array('nodeTranslation' => $nodeTranslation));

        if (!\is_null($queuedNodeTranslationAction)) {
            $this->em->remove($queuedNodeTranslationAction);
            $this->em->flush();
        }
    }

    /**
     * This shouldn't be here either but it's an improvement.
     *
     * @param HasNodeInterface $page            The page
     * @param NodeTranslation  $nodeTranslation The node translation
     * @param NodeVersion      $nodeVersion     The node version
     * @param BaseUser         $user            The user
     *
     * @return mixed
     */
    public function createPublicVersion(
        HasNodeInterface $page,
        NodeTranslation $nodeTranslation,
        NodeVersion $nodeVersion,
        BaseUser $user
    ) {
        $newPublicPage = $this->cloneHelper->deepCloneAndSave($page);
        $newNodeVersion = $this->em->getRepository(NodeVersion::class)->createNodeVersionFor(

It seems like you code against a concrete implementation and not the interface Doctrine\Persistence\ObjectRepository as the method createNodeVersionFor() does only exist in the following implementations of said interface: Kunstmaan\NodeBundle\Repository\NodeVersionRepository.

            $newPublicPage,
            $nodeTranslation,
            $user,
            $nodeVersion
        );

        $newNodeVersion
            ->setOwner($nodeVersion->getOwner())
            ->setUpdated($nodeVersion->getUpdated())
            ->setCreated($nodeVersion->getCreated());

        $nodeVersion
            ->setOwner($user)
            ->setCreated(new \DateTime())
            ->setOrigin($newNodeVersion);

        $this->em->persist($newNodeVersion);
        $this->em->persist($nodeVersion);
        $this->em->persist($nodeTranslation);
        $this->em->flush();
        $this->dispatch(
            new NodeEvent($nodeTranslation->getNode(), $nodeTranslation, $nodeVersion, $newPublicPage),
            Events::CREATE_PUBLIC_VERSION
        );

        return $newNodeVersion;
    }

    /**
     * @param Request         $request
     * @param NodeTranslation $nodeTranslation
     */
    public function chooseHowToPublish(Request $request, NodeTranslation $nodeTranslation, TranslatorInterface $translator)

This method seems to be duplicated in your project.

    {
        /** @var Session $session */
        $session = $request->getSession();

        if ($request->request->has('publish_later') && $request->get('pub_date')) {
            $date = new \DateTime(
                $request->get('pub_date') . ' ' . $request->get('pub_time')
            );
            $this->publishLater($nodeTranslation, $date);
            $session->getFlashBag()->add(
                FlashTypes::SUCCESS,
                $translator->trans('kuma_node.admin.publish.flash.success_scheduled')
            );
        } else {
            $this->publish($nodeTranslation);
            $session->getFlashBag()->add(
                FlashTypes::SUCCESS,
                $translator->trans('kuma_node.admin.publish.flash.success_published')
            );
        }
    }

    /**
     * @param Request         $request
     * @param NodeTranslation $nodeTranslation
     */
    public function chooseHowToUnpublish(Request $request, NodeTranslation $nodeTranslation, TranslatorInterface $translator)

This method seems to be duplicated in your project.

    {
        /** @var Session $session */
        $session = $request->getSession();

        if ($request->request->has('unpublish_later') && $request->get('unpub_date')) {
            $date = new \DateTime($request->get('unpub_date') . ' ' . $request->get('unpub_time'));
            $this->unPublishLater($nodeTranslation, $date);
            $session->getFlashBag()->add(
                FlashTypes::SUCCESS,
                $translator->trans('kuma_node.admin.unpublish.flash.success_scheduled')
            );
        } else {
            $this->unPublish($nodeTranslation);
            $session->getFlashBag()->add(
                FlashTypes::SUCCESS,
                $translator->trans('kuma_node.admin.unpublish.flash.success_unpublished')
            );
        }
    }

    /**
     * @param object $event
     * @param string $eventName
     *
     * @return object
     */
    private function dispatch($event, string $eventName)

This method seems to be duplicated in your project.

    {
        if (class_exists(LegacyEventDispatcherProxy::class)) {
            $eventDispatcher = LegacyEventDispatcherProxy::decorate($this->eventDispatcher);

            return $eventDispatcher->dispatch($event, $eventName);
        }

        return $this->eventDispatcher->dispatch($eventName, $event);
    }
}