nineskeletor/src/Repository/ItemRepository.php

<?php

namespace App\Repository;

use App\Entity\Item;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Persistence\ManagerRegistry;

/**
 * @extends ServiceEntityRepository<Item>
 *
 * @method Item|null find($id, $lockMode = null, $lockVersion = null)
 * @method Item|null findOneBy(array $criteria, array $orderBy = null)
 * @method Item[]    findAll()
 * @method Item[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
 */
class ItemRepository extends ServiceEntityRepository
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Item::class);
    }

    public function save(Item $entity, bool $flush = false): void
    {
        $this->getEntityManager()->persist($entity);

        if ($flush) {
            $this->getEntityManager()->flush();
        }
    }

    public function remove(Item $entity, bool $flush = false): void
    {
        $this->getEntityManager()->remove($entity);

        if ($flush) {
            $this->getEntityManager()->flush();
        }
    }

    public function getUserItems($user, &$bookmarks, &$itemsordered, &$itemcategorys, $iditemcategory = null, $withbookmark = 1, $fgessential = false)
    {
        // Profilage
        $roles = ($user ? $user->getRoles() : ['ROLE_ANONYME']);
        $groups = ($user ? $user->getGroups() : []);

        // Bookmark de l'utilisateur
        $bookmarks = [];
        if ($user) {
            $bookmarks = $this->getEntityManager()->getRepository("App\Entity\Bookmark")->findBy(['user' => $user]);
        }

        $itemcategoryfilter = null;
        if ($iditemcategory) {
            $itemcategoryfilter = $this->getEntityManager()->getRepository("App\Entity\Itemcategory")->findBy(['id' => $iditemcategory]);
        }

        // Bookmark lié à un item
        $bookmarksitems = new ArrayCollection();
        if (0 == $withbookmark) {
            foreach ($bookmarks as $bookmark) {
                if ($bookmark->getItem()) {
                    $bookmarksitems->add($bookmark->getItem());
                }
            }
        }

        // Initialisation du calcul des items
        $items = new ArrayCollection();
        $itemalls = new ArrayCollection();

        // Récupération des items par rôles
        $itemsroles = [];
        foreach ($roles as $role) {
            $qb = $this->getEntityManager()->createQueryBuilder();
            $qb->select('item')
                ->from("App\Entity\Item", 'item')
                ->where($qb->expr()->like('item.roles', $qb->expr()->literal("%$role%")));

            if ($iditemcategory && $itemcategoryfilter) {
                $qb->andWhere('item.itemcategory=:itemcategory')
                   ->setParameter('itemcategory', $itemcategoryfilter);
            }

            $itemsroles = $qb->getQuery()->getResult();
            foreach ($itemsroles as $itemrole) {
                if (!$bookmarksitems->contains($itemrole) && !$items->contains($itemrole)) {
                    if (!$fgessential || ($fgessential && $itemrole->isEssential())) {
                        $items->add($itemrole);
                    }
                }

                if (!$itemalls->contains($itemrole)) {
                    $itemalls->add($itemrole);
                }
            }
        }

        // Récupération des items par group
        $itemsgroups = [];
        foreach ($groups as $group) {
            $qb = $this->getEntityManager()->createQueryBuilder();
            $qb->select('item')
                ->from("App\Entity\Item", 'item')
                ->where(':group MEMBER OF item.groups')
                ->setParameter('group', $group->getGroup());

            if ($iditemcategory && $itemcategoryfilter) {
                $qb->andWhere('item.itemcategory=:itemcategory')
                   ->setParameter('itemcategory', $itemcategoryfilter);
            }

            $itemsgroups = $qb->getQuery()->getResult();
            foreach ($itemsgroups as $itemgroup) {
                if (!$bookmarksitems->contains($itemgroup) && !$items->contains($itemgroup)) {
                    if (!$fgessential || ($fgessential && $itemgroup->isEssential())) {
                        $items->add($itemgroup);
                    }
                }

                if (!$itemalls->contains($itemgroup)) {
                    $itemalls->add($itemgroup);
                }
            }
        }

        // Pour chaque bookmark lié à un item : on vérifie qu'il est tjr la permission de voir cet item sinon on l'enlève de ses fav
        foreach ($bookmarks as $key => $bookmark) {
            $item = $bookmark->getItem();
            if ($item) {
                if (!$itemalls->contains($item)) {
                    unset($bookmarks[$key]);
                }
            }
        }

        // Trie des items
        $itemsordered = $items->getIterator();
        $itemsordered->uasort(function ($first, $second) {
            if ((int) $first->getRowOrder() > (int) $second->getRowOrder()) {
                $return = 1;
            } elseif ((int) $first->getRowOrder() == (int) $second->getRowOrder()) {
                if ($first->getTitle() > $second->getTitle()) {
                    $return = 1;
                } else {
                    $return = -1;
                }
            } else {
                $return = -1;
            }

            return $return;
        });
        $itemsordered = iterator_to_array($itemsordered);

        switch ($withbookmark) {
            // items uniquement
            case 1: $bookmarks = null;
                break;

                // bookmarks uniquement
            case 2: $itemsordered = null;
                break;
        }

        // Catégories affichées
        $itemcategorys = new ArrayCollection();
        if ($iditemcategory && $itemcategoryfilter) {
            $itemcategorys = $itemcategoryfilter;
            if (empty($itemsordered)) {
                $itemcategorys = null;
            }
        } elseif ($itemsordered) {
            foreach ($itemsordered as $key => $item) {
                if (!$itemcategorys->contains($item->getItemcategory())) {
                    $itemcategorys->add($item->getItemcategory());
                }
            }

            // Trie des itemcategorys
            $itemcategorysordered = $itemcategorys->getIterator();
            $itemcategorysordered->uasort(function ($first, $second) {
                if ((int) $first->getRowOrder() > (int) $second->getRowOrder()) {
                    $return = 1;
                } else {
                    $return = -1;
                }

                return $return;
            });
            $itemcategorys = iterator_to_array($itemcategorysordered);
        }
    }
}