Core\Repository\DoctrineMongoODM\Event\AbstractUpdateFilesPermissionsSubscriber

Complexity

Total Complexity

11

Size/Duplication

Total Lines	101
Duplicated Lines	12.87 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	1
Bugs	0	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getSubscribedEvents()	0	4	1
A	onFlush()	0	17	3
A	process()	13	21	4
A	getFiles()	0	17	3

<?php
/**
 * YAWIK
 *
 * @filesource
 * @license MIT
 * @copyright  2013 - 2016 Cross Solution <http://cross-solution.de>
 */
  
/** */
namespace Core\Repository\DoctrineMongoODM\Event;

use Core\Entity\PermissionsAwareInterface;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\EventSubscriber;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\Event\OnFlushEventArgs;
use Doctrine\ODM\MongoDB\Events;
use Doctrine\ODM\MongoDB\UnitOfWork;
use Zend\Stdlib\ArrayUtils;

/**
 * Boilerplate for Files permissions update subscriber.
 *
 * updates the permissions of embedded files if the permissions on the parent document
 * had changed.
 * 
 * @author Mathias Gelhausen <gelhausen@cross-solution.de>
 * @since 0.26
 */
abstract class AbstractUpdateFilesPermissionsSubscriber implements EventSubscriber
{
    /**
     * List of properties where embedded files can be retreived.
     *
     * Note: entries will be prepended with "get"
     *
     * @var string[]
     */
    protected $filesProperties = [];

    /**
     * The document class that should be watched.
     *
     * @var string
     */
    protected $targetDocument;


    public function getSubscribedEvents()
    {
        return [ Events::onFlush ];
    }

    /**
     * Updates permissions on embedded files.
     *
     * @param OnFlushEventArgs $args
     */
    public function onFlush(OnFlushEventArgs $args)
    {
        $dm = $args->getDocumentManager();
        $uow = $dm->getUnitOfWork();

        $filter = function($element) {
            return $element instanceOf $this->targetDocument
                   && $element instanceOf PermissionsAwareInterface
                   && $element->getPermissions()->hasChanged();
        };

        $inserts = array_filter($uow->getScheduledDocumentInsertions(), $filter);
        $updates = array_filter($uow->getScheduledDocumentUpdates(), $filter);

        $this->process($inserts);
        $this->process($updates, $dm, $uow);
    }

    /**
     *
     *
     * @param PermissionsAwareInterface[] $documents
     * @param null|DocumentManager $dm
     * @param null|UnitOfWork $uow
     */
    protected function process($documents, $dm = null, $uow = null)
    {
        foreach ($documents as $document) {
            $perms = $document->getPermissions();
            $files = $this->getFiles($document);

$document is of type object<Core\Entity\PermissionsAwareInterface>, but the function expects a object<Core\Entity\EntityInterface>.

            foreach ($files as $file) {

This code seems to be duplicated across your project.

                $file
                    ->getPermissions()
                    ->clear()
                    ->inherit($perms);

                if ($dm) {
                    $uow->computeChangeSet(

It seems like $uow is not always an object, but can also be of type null. Maybe add an additional type check?

                        $dm->getClassMetadata(get_class($file)),
                        $file
                    );
                }
            }
        }
    }

    /**
     *
     *
     * @param \Core\Entity\EntityInterface $document
     *
     * @return PermissionsAwareInterface[]
     */
    protected function getFiles($document)
    {
        $files = [];

        foreach ($this->filesProperties as $prop) {
            $getter = "get$prop";
            $file   = $document->$getter();
            if ($file instanceof Collection) {
                $files = array_merge($files, ArrayUtils::iteratorToArray($file));

            } else {
                $files[] = $file;
            }
        }

        return array_filter($files, function($i) { return $i instanceOf PermissionsAwareInterface; });
    }
}