Issues in FolderRepository.php - All Issues - Inspection of "update webpack + add kunstmaan linters + cleanup g..." - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 91fdab...75a7b9 )

unknown

created 2018-11-22 13:42 UTC

MediaBundle/Repository/FolderRepository.php (1 issue)

Labels

Duplication 1

Severity

Informational 1

wouterv55 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Kunstmaan\MediaBundle\Repository;

use Doctrine\ORM\EntityNotFoundException;
use Doctrine\ORM\Query;
use Doctrine\ORM\QueryBuilder;
use Gedmo\Tree\Entity\Repository\NestedTreeRepository;
use Kunstmaan\MediaBundle\Entity\Folder;
use Kunstmaan\MediaBundle\Entity\Media;

/**
 * FolderRepository
 *
 * @method FolderRepository persistAsFirstChild(object $node)
 * @method FolderRepository persistAsFirstChildOf(object $node, object $parent)
 * @method FolderRepository persistAsLastChild(object $node)
 * @method FolderRepository persistAsLastChildOf(object $node, object $parent)
 * @method FolderRepository persistAsNextSibling(object $node)
 * @method FolderRepository persistAsNextSiblingOf(object $node, object $sibling)
 * @method FolderRepository persistAsPrevSibling(object $node)
 * @method FolderRepository persistAsPrevSiblingOf(object $node, object $sibling)
 */
class FolderRepository extends NestedTreeRepository
{
    /**
     * @param Folder $folder The folder
     *
     * @throws \Exception
     */
    public function save(Folder $folder)
    {
        $em     = $this->getEntityManager();
        $parent = $folder->getParent();

        $em->beginTransaction();
        try {
            if (!is_null($parent)) {
                $this->persistInOrderedTree($folder, $parent);
            } else {
                $em->persist($folder);
            }
            $em->commit();
            $em->flush();
        } catch (\Exception $e) {
            $em->rollback();
            throw $e;
        }
    }

    /**
     * @param Folder $folder
     */
    public function delete(Folder $folder)
    {
        $em = $this->getEntityManager();

        $this->deleteMedia($folder);
        $this->deleteChildren($folder);
        $folder->setDeleted(true);
        $em->persist($folder);
        $em->flush();
    }


    /**
     * @param Folder $folder
     * @param bool $alsoDeleteFolders
     */
    public function emptyFolder(Folder $folder, $alsoDeleteFolders = false)

    {
        $em = $this->getEntityManager();
        $this->deleteMedia($folder);
        if ($alsoDeleteFolders) {
            $this->deleteChildren($folder);
        }
        $em->flush();
    }

    /**
     * @param Folder $folder
     */
    private function deleteMedia(Folder $folder)
    {
        $em = $this->getEntityManager();

        /** @var Media $media */
        foreach ($folder->getMedia() as $media) {
            $media->setDeleted(true);
            $em->persist($media);
        }
    }

    /**
     * @param Folder $folder
     */
    private function deleteChildren(Folder $folder)
    {
        $em = $this->getEntityManager();

        /** @var Folder $child */
        foreach ($folder->getChildren() as $child) {
            $this->deleteMedia($child);
            $this->deleteChildren($child);
            $child->setDeleted(true);
            $em->persist($child);
        }
    }

    /**
     * @param int $limit
     *
     * @return array
     */
    public function getAllFolders($limit = null)
    {
        $qb = $this->createQueryBuilder('folder')
            ->select('folder')
            ->where('folder.parent is null AND folder.deleted != true')
            ->orderBy('folder.name');

        if (false === is_null($limit)) {
            $qb->setMaxResults($limit);
        }

        return $qb->getQuery()->getResult();
    }

    /**
     * @param int $folderId
     *
     * @return object
     * @throws EntityNotFoundException
     */
    public function getFolder($folderId)
    {
        $folder = $this->find($folderId);
        if (!$folder) {
            throw new EntityNotFoundException();
        }

        return $folder;
    }

    public function getFirstTopFolder()
    {
        $folder = $this->findOneBy(array('parent' => null));
        if (!$folder) {
            throw new EntityNotFoundException();
        }

        return $folder;
    }

    public function getParentIds(Folder $folder)
    {
        /** @var QueryBuilder $qb */
        $qb = $this->getPathQueryBuilder($folder)
            ->select('node.id');

        $result = $qb->getQuery()->getScalarResult();
        $ids    = array_map('current', $result);

        return $ids;
    }

    /**
     * {@inheritdoc}
     */
    public function getPathQueryBuilder($node)
    {
        /** @var QueryBuilder $qb */
        $qb = parent::getPathQueryBuilder($node);
        $qb->andWhere('node.deleted != true');

        return $qb;
    }

    /**
     * {@inheritdoc}
     */
    public function getRootNodesQueryBuilder($sortByField = null, $direction = 'asc')
    {
        /** @var QueryBuilder $qb */
        $qb = parent::getRootNodesQueryBuilder($sortByField, $direction);
        $qb->andWhere('node.deleted != true');

        return $qb;
    }

    /**
     * {@inheritdoc}
     */
    public function childrenQueryBuilder(
        $node = null,
        $direct = false,
        $sortByField = null,
        $direction = 'ASC',
        $includeNode = false
    ) {
        /** @var QueryBuilder $qb */
        $qb = parent::childrenQueryBuilder($node, $direct, $sortByField, $direction, $includeNode);
        $qb->andWhere('node.deleted != true');

        return $qb;
    }

    /**
     * {@inheritdoc}
     */
    public function getLeafsQueryBuilder($root = null, $sortByField = null, $direction = 'ASC')
    {
        /** @var QueryBuilder $qb */
        $qb = parent::getLeafsQueryBuilder($root, $sortByField, $direction);
        $qb->andWhere('node.deleted != true');

        return $qb;
    }

    /**
     * {@inheritdoc}
     */
    public function getNextSiblingsQueryBuilder($node, $includeSelf = false)
    {
        /** @var QueryBuilder $qb */
        $qb = parent::getNextSiblingsQueryBuilder($node, $includeSelf);
        $qb->andWhere('node.deleted != true');

        return $qb;
    }

    /**
     * {@inheritdoc}
     */
    public function getPrevSiblingsQueryBuilder($node, $includeSelf = false)
    {
        /** @var QueryBuilder $qb */
        $qb = parent::getPrevSiblingsQueryBuilder($node, $includeSelf);
        $qb->andWhere('node.deleted != true');

        return $qb;
    }

    /**
     * {@inheritdoc}
     */
    public function getNodesHierarchyQueryBuilder(
        $node = null,
        $direct = false,
        array $options = array(),
        $includeNode = false
    ) {
        /** @var QueryBuilder $qb */
        $qb = parent::getNodesHierarchyQueryBuilder($node, $direct, $options, $includeNode);
        $qb->andWhere('node.deleted != true');

        return $qb;
    }

    /**
     * {@inheritdoc}
     */
    public function getNodesHierarchy($node = null, $direct = false, array $options = array(), $includeNode = false)
    {
        $query = $this->getNodesHierarchyQuery($node, $direct, $options, $includeNode);
        $query->setHint(
            Query::HINT_CUSTOM_OUTPUT_WALKER,
            'Gedmo\\Translatable\\Query\\TreeWalker\\TranslationWalker'
        );

        return $query->getArrayResult();
    }

    /**
     * Rebuild the nested tree
     */
    public function rebuildTree()
    {
        $em = $this->getEntityManager();

        // Reset tree...
        $sql  = 'UPDATE kuma_folders SET lvl=NULL,lft=NULL,rgt=NULL';
        $stmt = $em->getConnection()->prepare($sql);
        $stmt->execute();

        $folders = $this->findBy(array(), array('parent' => 'ASC', 'name' => 'asc'));

        $rootFolder = $folders[0];
        $first      = true;
        foreach ($folders as $folder) {
            // Force parent load
            $parent = $folder->getParent();
            if (is_null($parent)) {
                $folder->setLevel(0);
                if ($first) {
                    $this->persistAsFirstChild($folder);
                    $first = false;
                } else {
                    $this->persistAsNextSiblingOf($folder, $rootFolder);
                }
            } else {
                $folder->setLevel($parent->getLevel() + 1);
                $this->persistAsLastChildOf($folder, $parent);
            }
        }
        $em->flush();
    }

    /**
     * Used as querybuilder for Folder entity selectors
     *
     * @param Folder $ignoreSubtree Folder (with children) that has to be filtered out (optional)
     *
     * @return QueryBuilder
     */
    public function selectFolderQueryBuilder(Folder $ignoreSubtree = null)
    {
        /** @var QueryBuilder $qb */
        $qb = $this->createQueryBuilder('f');
        $qb->where('f.deleted != true')
            ->orderBy('f.lft');

        // Fetch all folders except the current one and its children
        if (!is_null($ignoreSubtree) && $ignoreSubtree->getId() !== null) {
            $orX = $qb->expr()->orX();
            $orX->add('f.rgt > :right')
                ->add('f.lft < :left');

            $qb->andWhere($orX)
                ->setParameter('left', $ignoreSubtree->getLeft())
                ->setParameter('right', $ignoreSubtree->getRight());
        }

        return $qb;
    }

    /**
     * @param Folder $folder
     * @param        $parent
     */
    private function persistInOrderedTree(Folder $folder, $parent)
    {
        // Find where to insert the new item
        $children = $parent->getChildren(true);
        if ($children->isEmpty()) {
            // No children yet - insert as first child
            $this->persistAsFirstChildOf($folder, $parent);
        } else {
            $previousChild = null;
            foreach ($children as $child) {
                // Alphabetical sorting - could be nice if we implemented a sorting strategy
                if (strcasecmp($folder->getName(), $child->getName()) < 0) {
                    break;
                }
                $previousChild = $child;
            }
            if (is_null($previousChild)) {
                $this->persistAsPrevSiblingOf($folder, $children[0]);
            } else {
                $this->persistAsNextSiblingOf($folder, $previousChild);
            }
        }
    }
}


1		<?php
2
3		namespace Kunstmaan\MediaBundle\Repository;
4
5		use Doctrine\ORM\EntityNotFoundException;
6		use Doctrine\ORM\Query;
7		use Doctrine\ORM\QueryBuilder;
8		use Gedmo\Tree\Entity\Repository\NestedTreeRepository;
9		use Kunstmaan\MediaBundle\Entity\Folder;
10		use Kunstmaan\MediaBundle\Entity\Media;
11
12		/**
13		* FolderRepository
14		*
15		* @method FolderRepository persistAsFirstChild(object $node)
16		* @method FolderRepository persistAsFirstChildOf(object $node, object $parent)
17		* @method FolderRepository persistAsLastChild(object $node)
18		* @method FolderRepository persistAsLastChildOf(object $node, object $parent)
19		* @method FolderRepository persistAsNextSibling(object $node)
20		* @method FolderRepository persistAsNextSiblingOf(object $node, object $sibling)
21		* @method FolderRepository persistAsPrevSibling(object $node)
22		* @method FolderRepository persistAsPrevSiblingOf(object $node, object $sibling)
23		*/
24		class FolderRepository extends NestedTreeRepository
25		{
26		/**
27		* @param Folder $folder The folder
28		*
29		* @throws \Exception
30		*/
31		public function save(Folder $folder)
32		{
33		$em = $this->getEntityManager();
34		$parent = $folder->getParent();
35
36		$em->beginTransaction();
37		try {
38		if (!is_null($parent)) {
39		$this->persistInOrderedTree($folder, $parent);
40		} else {
41		$em->persist($folder);
42		}
43		$em->commit();
44		$em->flush();
45		} catch (\Exception $e) {
46		$em->rollback();
47		throw $e;
48		}
49		}
50
51		/**
52		* @param Folder $folder
53		*/
54	View Code Duplication	public function delete(Folder $folder)
55		{
56		$em = $this->getEntityManager();
57
58		$this->deleteMedia($folder);
59		$this->deleteChildren($folder);
60		$folder->setDeleted(true);
61		$em->persist($folder);
62		$em->flush();
63		}
64
65
66		/**
67		* @param Folder $folder
68		* @param bool $alsoDeleteFolders
69		*/
70	View Code Duplication	public function emptyFolder(Folder $folder, $alsoDeleteFolders = false)
		0 ignored issues – show Duplication introduced 2017-11-21 06:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
71		{
72		$em = $this->getEntityManager();
73		$this->deleteMedia($folder);
74		if ($alsoDeleteFolders) {
75		$this->deleteChildren($folder);
76		}
77		$em->flush();
78		}
79
80		/**
81		* @param Folder $folder
82		*/
83		private function deleteMedia(Folder $folder)
84		{
85		$em = $this->getEntityManager();
86
87		/** @var Media $media */
88		foreach ($folder->getMedia() as $media) {
89		$media->setDeleted(true);
90		$em->persist($media);
91		}
92		}
93
94		/**
95		* @param Folder $folder
96		*/
97	View Code Duplication	private function deleteChildren(Folder $folder)
98		{
99		$em = $this->getEntityManager();
100
101		/** @var Folder $child */
102		foreach ($folder->getChildren() as $child) {
103		$this->deleteMedia($child);
104		$this->deleteChildren($child);
105		$child->setDeleted(true);
106		$em->persist($child);
107		}
108		}
109
110		/**
111		* @param int $limit
112		*
113		* @return array
114		*/
115		public function getAllFolders($limit = null)
116		{
117		$qb = $this->createQueryBuilder('folder')
118		->select('folder')
119		->where('folder.parent is null AND folder.deleted != true')
120		->orderBy('folder.name');
121
122		if (false === is_null($limit)) {
123		$qb->setMaxResults($limit);
124		}
125
126		return $qb->getQuery()->getResult();
127		}
128
129		/**
130		* @param int $folderId
131		*
132		* @return object
133		* @throws EntityNotFoundException
134		*/
135		public function getFolder($folderId)
136		{
137		$folder = $this->find($folderId);
138		if (!$folder) {
139		throw new EntityNotFoundException();
140		}
141
142		return $folder;
143		}
144
145		public function getFirstTopFolder()
146		{
147		$folder = $this->findOneBy(array('parent' => null));
148		if (!$folder) {
149		throw new EntityNotFoundException();
150		}
151
152		return $folder;
153		}
154
155		public function getParentIds(Folder $folder)
156		{
157		/** @var QueryBuilder $qb */
158		$qb = $this->getPathQueryBuilder($folder)
159		->select('node.id');
160
161		$result = $qb->getQuery()->getScalarResult();
162		$ids = array_map('current', $result);
163
164		return $ids;
165		}
166
167		/**
168		* {@inheritdoc}
169		*/
170		public function getPathQueryBuilder($node)
171		{
172		/** @var QueryBuilder $qb */
173		$qb = parent::getPathQueryBuilder($node);
174		$qb->andWhere('node.deleted != true');
175
176		return $qb;
177		}
178
179		/**
180		* {@inheritdoc}
181		*/
182		public function getRootNodesQueryBuilder($sortByField = null, $direction = 'asc')
183		{
184		/** @var QueryBuilder $qb */
185		$qb = parent::getRootNodesQueryBuilder($sortByField, $direction);
186		$qb->andWhere('node.deleted != true');
187
188		return $qb;
189		}
190
191		/**
192		* {@inheritdoc}
193		*/
194		public function childrenQueryBuilder(
195		$node = null,
196		$direct = false,
197		$sortByField = null,
198		$direction = 'ASC',
199		$includeNode = false
200		) {
201		/** @var QueryBuilder $qb */
202		$qb = parent::childrenQueryBuilder($node, $direct, $sortByField, $direction, $includeNode);
203		$qb->andWhere('node.deleted != true');
204
205		return $qb;
206		}
207
208		/**
209		* {@inheritdoc}
210		*/
211		public function getLeafsQueryBuilder($root = null, $sortByField = null, $direction = 'ASC')
212		{
213		/** @var QueryBuilder $qb */
214		$qb = parent::getLeafsQueryBuilder($root, $sortByField, $direction);
215		$qb->andWhere('node.deleted != true');
216
217		return $qb;
218		}
219
220		/**
221		* {@inheritdoc}
222		*/
223		public function getNextSiblingsQueryBuilder($node, $includeSelf = false)
224		{
225		/** @var QueryBuilder $qb */
226		$qb = parent::getNextSiblingsQueryBuilder($node, $includeSelf);
227		$qb->andWhere('node.deleted != true');
228
229		return $qb;
230		}
231
232		/**
233		* {@inheritdoc}
234		*/
235		public function getPrevSiblingsQueryBuilder($node, $includeSelf = false)
236		{
237		/** @var QueryBuilder $qb */
238		$qb = parent::getPrevSiblingsQueryBuilder($node, $includeSelf);
239		$qb->andWhere('node.deleted != true');
240
241		return $qb;
242		}
243
244		/**
245		* {@inheritdoc}
246		*/
247		public function getNodesHierarchyQueryBuilder(
248		$node = null,
249		$direct = false,
250		array $options = array(),
251		$includeNode = false
252		) {
253		/** @var QueryBuilder $qb */
254		$qb = parent::getNodesHierarchyQueryBuilder($node, $direct, $options, $includeNode);
255		$qb->andWhere('node.deleted != true');
256
257		return $qb;
258		}
259
260		/**
261		* {@inheritdoc}
262		*/
263		public function getNodesHierarchy($node = null, $direct = false, array $options = array(), $includeNode = false)
264		{
265		$query = $this->getNodesHierarchyQuery($node, $direct, $options, $includeNode);
266		$query->setHint(
267		Query::HINT_CUSTOM_OUTPUT_WALKER,
268		'Gedmo\\Translatable\\Query\\TreeWalker\\TranslationWalker'
269		);
270
271		return $query->getArrayResult();
272		}
273
274		/**
275		* Rebuild the nested tree
276		*/
277		public function rebuildTree()
278		{
279		$em = $this->getEntityManager();
280
281		// Reset tree...
282		$sql = 'UPDATE kuma_folders SET lvl=NULL,lft=NULL,rgt=NULL';
283		$stmt = $em->getConnection()->prepare($sql);
284		$stmt->execute();
285
286		$folders = $this->findBy(array(), array('parent' => 'ASC', 'name' => 'asc'));
287
288		$rootFolder = $folders[0];
289		$first = true;
290		foreach ($folders as $folder) {
291		// Force parent load
292		$parent = $folder->getParent();
293		if (is_null($parent)) {
294		$folder->setLevel(0);
295		if ($first) {
296		$this->persistAsFirstChild($folder);
297		$first = false;
298		} else {
299		$this->persistAsNextSiblingOf($folder, $rootFolder);
300		}
301		} else {
302		$folder->setLevel($parent->getLevel() + 1);
303		$this->persistAsLastChildOf($folder, $parent);
304		}
305		}
306		$em->flush();
307		}
308
309		/**
310		* Used as querybuilder for Folder entity selectors
311		*
312		* @param Folder $ignoreSubtree Folder (with children) that has to be filtered out (optional)
313		*
314		* @return QueryBuilder
315		*/
316		public function selectFolderQueryBuilder(Folder $ignoreSubtree = null)
317		{
318		/** @var QueryBuilder $qb */
319		$qb = $this->createQueryBuilder('f');
320		$qb->where('f.deleted != true')
321		->orderBy('f.lft');
322
323		// Fetch all folders except the current one and its children
324		if (!is_null($ignoreSubtree) && $ignoreSubtree->getId() !== null) {
325		$orX = $qb->expr()->orX();
326		$orX->add('f.rgt > :right')
327		->add('f.lft < :left');
328
329		$qb->andWhere($orX)
330		->setParameter('left', $ignoreSubtree->getLeft())
331		->setParameter('right', $ignoreSubtree->getRight());
332		}
333
334		return $qb;
335		}
336
337		/**
338		* @param Folder $folder
339		* @param $parent
340		*/
341		private function persistInOrderedTree(Folder $folder, $parent)
342		{
343		// Find where to insert the new item
344		$children = $parent->getChildren(true);
345		if ($children->isEmpty()) {
346		// No children yet - insert as first child
347		$this->persistAsFirstChildOf($folder, $parent);
348		} else {
349		$previousChild = null;
350		foreach ($children as $child) {
351		// Alphabetical sorting - could be nice if we implemented a sorting strategy
352		if (strcasecmp($folder->getName(), $child->getName()) < 0) {
353		break;
354		}
355		$previousChild = $child;
356		}
357		if (is_null($previousChild)) {
358		$this->persistAsPrevSiblingOf($folder, $children[0]);
359		} else {
360		$this->persistAsNextSiblingOf($folder, $previousChild);
361		}
362		}
363		}
364		}
365

Kunstmaan / KunstmaanBundlesCMS

Push — master ( 91fdab...75a7b9 )

MediaBundle/Repository/FolderRepository.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like