Uxmp\Core\Orm\Repository\AlbumRepository

Complexity

Total Complexity

14

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	delete()	0	6	1
A	getListOrderedByArtist()	0	26	3
A	search()	0	14	1
A	findByGenre()	0	43	3
A	findEmptyAlbums()	0	19	1
A	prototype()	0	3	1
A	getFavorites()	0	49	2
A	findByMbId()	0	4	1
A	save()	0	6	1

<?php

declare(strict_types=1);

namespace Uxmp\Core\Orm\Repository;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Query\Expr\Join;
use Doctrine\ORM\Query\Parameter;
use Generator;
use Uxmp\Core\Orm\Model\Album;
use Uxmp\Core\Orm\Model\AlbumInterface;
use Uxmp\Core\Orm\Model\Artist;
use Uxmp\Core\Orm\Model\CatalogInterface;
use Uxmp\Core\Orm\Model\Disc;
use Uxmp\Core\Orm\Model\Favorite;
use Uxmp\Core\Orm\Model\FavoriteItemTypeEnum;
use Uxmp\Core\Orm\Model\GenreInterface;
use Uxmp\Core\Orm\Model\GenreMap;
use Uxmp\Core\Orm\Model\GenreMapEnum;
use Uxmp\Core\Orm\Model\UserInterface;

/**
 * @extends EntityRepository<Album>
 *
 * @method AlbumInterface[] findBy(mixed[] $criteria, null|array $order = null, null|int $limit = null, null|int $offset = null)
 * @method null|AlbumInterface find(int $id)
 */
final class AlbumRepository extends EntityRepository implements AlbumRepositoryInterface
{
    public function prototype(): AlbumInterface
    {
        return new Album();
    }

    public function save(AlbumInterface $album): void
    {
        $em = $this->getEntityManager();

        $em->persist($album);
        $em->flush();
    }

    public function findByMbId(string $mbid): ?AlbumInterface
    {
        return $this->findOneBy([
            'mbid' => $mbid,
        ]);
    }

    /**
     * Returns albums having a certain genre
     *
     * @return Generator<AlbumInterface>
     */
    public function findByGenre(
        GenreInterface $genre,
        ?int $limit = null,
        ?int $offset = null,
        ?int $catalogId = null,
    ): Generator {
        $queryBuilder = $this->createQueryBuilder('a');
        $subQueryBuilder = $this
            ->getEntityManager()
            ->createQueryBuilder();
        $expressionBuilder = $this
            ->getEntityManager()
            ->getExpressionBuilder();

        $andExpression = $expressionBuilder->andX();
        $andExpression->add($expressionBuilder->eq('genre_map.genre', ':genre'));
        $andExpression->add($expressionBuilder->eq('genre_map.mapped_item_type', ':genreType'));

        $queryBuilder
            ->where(
                $expressionBuilder->in(
                    'a.id',
                    $subQueryBuilder
                        ->select('genre_map.mapped_item_id')
                        ->from(GenreMap::class, 'genre_map')
                        ->where($andExpression)
                        ->getDQL()
                )
            )
            ->setFirstResult($offset)
            ->setMaxResults($limit)
            ->orderBy('a.title', 'ASC')
            ->setParameter('genre', $genre)
            ->setParameter('genreType', GenreMapEnum::ALBUM)
        ;

        if ($catalogId !== null) {
            $queryBuilder->andWhere('catalog_id = :catalogId');
            $queryBuilder->setParameter('catalogId', $catalogId);
        }

        foreach ($queryBuilder->getQuery()->toIterable() as $item) {
            yield $item;
        }
    }

    public function delete(AlbumInterface $album): void
    {
        $em = $this->getEntityManager();

        $em->remove($album);
        $em->flush();
    }

    /**
     * @return iterable<AlbumInterface>
     */
    public function getFavorites(
        UserInterface $user,
        ?CatalogInterface $catalog = null,
        ?int $limit = null,
        ?int $offset = null
    ): iterable {
        $parameter = [
            new Parameter('user', $user),
            new Parameter('type', FavoriteItemTypeEnum::ALBUM),
        ];

        $qb = $this
            ->getEntityManager()
            ->createQueryBuilder();
        $qbSub = $this
            ->getEntityManager()
            ->createQueryBuilder();
        $expressionBuilder = $this
            ->getEntityManager()
            ->getExpressionBuilder();

        $andExpression = $expressionBuilder->andX();
        $andExpression->add($expressionBuilder->eq('fav.user', ':user'));
        $andExpression->add($expressionBuilder->eq('fav.type', ':type'));
        if ($catalog !== null) {
            $andExpression->add($expressionBuilder->eq('a.catalog', ':catalog'));

            $parameter[] = new Parameter('catalog', $catalog);
        }

        $qb
            ->select('a')
            ->from(Album::class, 'a')
            ->where(
                $expressionBuilder->in(
                    'a.id',
                    $qbSub
                        ->select('fav.item_id')
                        ->from(Favorite::class, 'fav')
                        ->where($andExpression)
                        ->getDQL()
                )
            )
            ->setParameters(new ArrayCollection($parameter))
            ->orderBy('a.title', 'ASC')
            ->setMaxResults($limit)
            ->setFirstResult($offset);

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

    public function findEmptyAlbums(CatalogInterface $catalog): iterable
    {
        $query = <<<SQL
            SELECT album
            FROM %s album
            LEFT JOIN %s disc 
            WITH disc.album_id = album.id
            WHERE album.catalog_id = %d
            GROUP BY album HAVING COUNT(disc.id) = 0
            SQL;

        return $this->getEntityManager()
            ->createQuery(sprintf(
                $query,
                Album::class,
                Disc::class,
                $catalog->getId(),
            ))
            ->getResult();
    }

    /**
     * Returns an ordered list by the albums artist
     *
     * @return Generator<AlbumInterface>
     */
    public function getListOrderedByArtist(
        null|int $limit = null,
        null|int $offset = null,
        ?int $catalogId = null,
    ): Generator {
        $query_builder = $this
            ->createQueryBuilder('ab')
            ->leftJoin(
                Artist::class,
                'ac',
                Join::WITH,
                'ac.id = ab.artist_id'
            )
            ->setFirstResult($offset)
            ->setMaxResults($limit)
            ->addOrderBy('ac.title', Criteria::ASC)

The constant Doctrine\Common\Collections\Criteria::ASC has been deprecated: use Order::Ascending instead

            ->addOrderBy('ab.title', Criteria::ASC)

The constant Doctrine\Common\Collections\Criteria::ASC has been deprecated: use Order::Ascending instead

        ;

        if ($catalogId !== null) {
            $query_builder->where('ab.catalog_id = :catalogId');
            $query_builder->setParameter('catalogId', $catalogId);
        }

        foreach ($query_builder->getQuery()->toIterable() as $album) {
            yield $album;
        }
    }

    public function search(string $searchTerm): array
    {
        $qb = $this->getEntityManager()->createQueryBuilder();

        $qb
            ->select('a')
            ->from(Album::class, 'a')
            ->where(
                $qb->expr()->like('a.searchTitle', ':searchTerm')
            )
            ->setParameter('searchTerm', sprintf('%%%s%%', mb_strtolower($searchTerm)))
        ;

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