EntryRepository::findByEmptyHashedUrlAndUserId() - Code Metrics - Inspection of "Merge pull request #4865 from wallabag/fix-4864" - wallabag/wallabag - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d20139...863dd6 )

by Nicolas

created 2020-12-21 07:53 UTC

EntryRepository::findByEmptyHashedUrlAndUserId() A

↳ Parent: EntryRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	5
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	7
rs	10

<?php

namespace Wallabag\CoreBundle\Repository;

use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\NoResultException;
use Doctrine\ORM\QueryBuilder;
use Pagerfanta\Doctrine\ORM\QueryAdapter as DoctrineORMAdapter;
use Pagerfanta\Pagerfanta;
use Wallabag\CoreBundle\Entity\Entry;
use Wallabag\CoreBundle\Entity\Tag;
use Wallabag\CoreBundle\Helper\UrlHasher;

class EntryRepository extends EntityRepository
{
    /**
     * Retrieves all entries for a user.
     *
     * @param int $userId
     *
     * @return QueryBuilder
     */
    public function getBuilderForAllByUser($userId)
    {
        return $this
            ->getSortedQueryBuilderByUser($userId)
        ;
    }

    /**
     * Retrieves unread entries for a user.
     *
     * @param int $userId
     *
     * @return QueryBuilder
     */
    public function getBuilderForUnreadByUser($userId)
    {
        return $this
            ->getSortedQueryBuilderByUser($userId)
            ->andWhere('e.isArchived = false')
        ;
    }

    /**
     * Retrieves read entries for a user.
     *
     * @param int $userId
     *
     * @return QueryBuilder
     */
    public function getBuilderForArchiveByUser($userId)
    {
        return $this
            ->getSortedQueryBuilderByUser($userId, 'archivedAt', 'desc')
            ->andWhere('e.isArchived = true')
        ;
    }

    /**
     * Retrieves starred entries for a user.
     *
     * @param int $userId
     *
     * @return QueryBuilder
     */
    public function getBuilderForStarredByUser($userId)
    {
        return $this
            ->getSortedQueryBuilderByUser($userId, 'starredAt', 'desc')
            ->andWhere('e.isStarred = true')
        ;
    }

    /**
     * Retrieves entries filtered with a search term for a user.
     *
     * @param int    $userId
     * @param string $term
     * @param string $currentRoute
     *
     * @return QueryBuilder
     */
    public function getBuilderForSearchByUser($userId, $term, $currentRoute)
    {
        $qb = $this
            ->getSortedQueryBuilderByUser($userId);

        if ('starred' === $currentRoute) {
            $qb->andWhere('e.isStarred = true');
        } elseif ('unread' === $currentRoute) {
            $qb->andWhere('e.isArchived = false');
        } elseif ('archive' === $currentRoute) {
            $qb->andWhere('e.isArchived = true');
        }

        // We lower() all parts here because PostgreSQL 'LIKE' verb is case-sensitive
        $qb
            ->andWhere('lower(e.content) LIKE lower(:term) OR lower(e.title) LIKE lower(:term) OR lower(e.url) LIKE lower(:term)')->setParameter('term', '%' . $term . '%')
            ->leftJoin('e.tags', 't')
            ->groupBy('e.id');

        return $qb;
    }

    /**
     * Retrieve a sorted list of untagged entries for a user.
     *
     * @param int $userId
     *
     * @return QueryBuilder
     */
    public function getBuilderForUntaggedByUser($userId)
    {
        return $this->sortQueryBuilder($this->getRawBuilderForUntaggedByUser($userId));
    }

    /**
     * Retrieve untagged entries for a user.
     *
     * @param int $userId
     *
     * @return QueryBuilder
     */
    public function getRawBuilderForUntaggedByUser($userId)
    {
        return $this->getQueryBuilderByUser($userId)
            ->leftJoin('e.tags', 't')
            ->andWhere('t.id is null');
    }

    /**
     * Retrieve the number of untagged entries for a user.
     *
     * @param int $userId
     *
     * @return int
     */
    public function countUntaggedEntriesByUser($userId)
    {
        return (int) $this->getRawBuilderForUntaggedByUser($userId)
            ->select('count(e.id)')
            ->getQuery()
            ->getSingleScalarResult();
    }

    /**
     * Find Entries.
     *
     * @param int    $userId
     * @param bool   $isArchived
     * @param bool   $isStarred
     * @param bool   $isPublic
     * @param string $sort
     * @param string $order
     * @param int    $since
     * @param string $tags
     * @param string $detail     'metadata' or 'full'. Include content field if 'full'
     *
     * @todo Breaking change: replace default detail=full by detail=metadata in a future version
     *
     * @return Pagerfanta
     */
    public function findEntries($userId, $isArchived = null, $isStarred = null, $isPublic = null, $sort = 'created', $order = 'asc', $since = 0, $tags = '', $detail = 'full')
    {
        if (!\in_array(strtolower($detail), ['full', 'metadata'], true)) {
            throw new \Exception('Detail "' . $detail . '" parameter is wrong, allowed: full or metadata');
        }

        $qb = $this->createQueryBuilder('e')
            ->leftJoin('e.tags', 't')
            ->where('e.user = :userId')->setParameter('userId', $userId);

        if ('metadata' === $detail) {
            $fieldNames = $this->getClassMetadata()->getFieldNames();
            $fields = array_filter($fieldNames, function ($k) {
                return 'content' !== $k;
            });
            $qb->select(sprintf('partial e.{%s}', implode(',', $fields)));
        }

        if (null !== $isArchived) {
            $qb->andWhere('e.isArchived = :isArchived')->setParameter('isArchived', (bool) $isArchived);
        }

        if (null !== $isStarred) {
            $qb->andWhere('e.isStarred = :isStarred')->setParameter('isStarred', (bool) $isStarred);
        }

        if (null !== $isPublic) {
            $qb->andWhere('e.uid IS ' . (true === $isPublic ? 'NOT' : '') . ' NULL');
        }

        if ($since > 0) {
            $qb->andWhere('e.updatedAt > :since')->setParameter('since', new \DateTime(date('Y-m-d H:i:s', $since)));
        }

        if (\is_string($tags) && '' !== $tags) {
            foreach (explode(',', $tags) as $i => $tag) {
                $entryAlias = 'e' . $i;
                $tagAlias = 't' . $i;

                // Complexe queries to ensure multiple tags are associated to an entry
                // https://stackoverflow.com/a/6638146/569101
                $qb->andWhere($qb->expr()->in(
                    'e.id',
                    $this->createQueryBuilder($entryAlias)
                        ->select($entryAlias . '.id')
                        ->leftJoin($entryAlias . '.tags', $tagAlias)
                        ->where($tagAlias . '.label = :label' . $i)
                        ->getDQL()
                ));

                // bound parameter to the main query builder
                $qb->setParameter('label' . $i, $tag);
            }
        }

        if (!\in_array(strtolower($order), ['asc', 'desc'], true)) {
            throw new \Exception('Order "' . $order . '" parameter is wrong, allowed: asc or desc');
        }

        if ('created' === $sort) {
            $qb->orderBy('e.id', $order);
        } elseif ('updated' === $sort) {
            $qb->orderBy('e.updatedAt', $order);
        } elseif ('archived' === $sort) {
            $qb->orderBy('e.archivedAt', $order);
        }

        $pagerAdapter = new DoctrineORMAdapter($qb, true, false);

        return new Pagerfanta($pagerAdapter);
    }

    /**
     * Fetch an entry with a tag. Only used for tests.
     *
     * @param int $userId
     *
     * @return array
     */
    public function findOneWithTags($userId)
    {
        $qb = $this->createQueryBuilder('e')
            ->innerJoin('e.tags', 't')
            ->innerJoin('e.user', 'u')
            ->addSelect('t', 'u')
            ->where('e.user = :userId')->setParameter('userId', $userId)
        ;

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

    /**
     * Find distinct language for a given user.
     * Used to build the filter language list.
     *
     * @param int $userId User id
     *
     * @return array
     */
    public function findDistinctLanguageByUser($userId)
    {
        $results = $this->createQueryBuilder('e')
            ->select('e.language')
            ->where('e.user = :userId')->setParameter('userId', $userId)
            ->andWhere('e.language IS NOT NULL')
            ->groupBy('e.language')
            ->orderBy('e.language', ' ASC')
            ->getQuery()
            ->getResult();

        $languages = [];
        foreach ($results as $result) {
            $languages[$result['language']] = $result['language'];
        }

        return $languages;
    }

    /**
     * Used only in test case to get the right entry associated to the right user.
     *
     * @param string $username
     *
     * @return Entry
     */
    public function findOneByUsernameAndNotArchived($username)
    {
        return $this->createQueryBuilder('e')
            ->leftJoin('e.user', 'u')
            ->where('u.username = :username')->setParameter('username', $username)
            ->andWhere('e.isArchived = false')
            ->setMaxResults(1)
            ->getQuery()
            ->getSingleResult();
    }

    /**
     * Remove a tag from all user entries.
     *
     * We need to loop on each entry attached to the given tag to remove it, since Doctrine doesn't know EntryTag entity because it's a ManyToMany relation.
     * It could be faster with one query but I don't know how to retrieve the table name `entry_tag` which can have a prefix:
     *
     * DELETE et FROM entry_tag et WHERE et.entry_id IN ( SELECT e.id FROM entry e WHERE e.user_id = :userId ) AND et.tag_id = :tagId
     *
     * @param int $userId
     */
    public function removeTag($userId, Tag $tag)
    {
        $entries = $this->getSortedQueryBuilderByUser($userId)
            ->innerJoin('e.tags', 't')
            ->andWhere('t.id = :tagId')->setParameter('tagId', $tag->getId())
            ->getQuery()
            ->getResult();

        foreach ($entries as $entry) {
            $entry->removeTag($tag);
        }

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

    /**
     * Remove tags from all user entries.
     *
     * @param int        $userId
     * @param Array<Tag> $tags
     */
    public function removeTags($userId, $tags)
    {
        foreach ($tags as $tag) {
            $this->removeTag($userId, $tag);
        }
    }

    /**
     * Find all entries that are attached to a give tag id.
     *
     * @param int $userId
     * @param int $tagId
     *
     * @return array
     */
    public function findAllByTagId($userId, $tagId)
    {
        return $this->getSortedQueryBuilderByUser($userId)
            ->innerJoin('e.tags', 't')
            ->andWhere('t.id = :tagId')->setParameter('tagId', $tagId)
            ->getQuery()
            ->getResult();
    }

    /**
     * Find an entry by its url and its owner.
     * If it exists, return the entry otherwise return false.
     *
     * @param string $url
     * @param int    $userId
     *
     * @return Entry|false
     */
    public function findByUrlAndUserId($url, $userId)
    {
        return $this->findByHashedUrlAndUserId(
            UrlHasher::hashUrl($url),
            $userId
        );
    }

    /**
     * Find all entries which have an empty value for hash.
     *
     * @return Entry|false
     */
    public function findByEmptyHashedUrlAndUserId(int $userId)
    {
        return $this->createQueryBuilder('e')

            ->where('e.hashedUrl = :empty')->setParameter('empty', '')
            ->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
            ->getQuery()
            ->getResult();
    }

    /**
     * Find an entry by its hashed url and its owner.
     * If it exists, return the entry otherwise return false.
     *
     * @param string $hashedUrl Url hashed using sha1
     * @param int    $userId
     *
     * @return Entry|false
     */
    public function findByHashedUrlAndUserId($hashedUrl, $userId)
    {
        // try first using hashed_url (to use the database index)
        $res = $this->createQueryBuilder('e')
            ->where('e.hashedUrl = :hashed_url')->setParameter('hashed_url', $hashedUrl)
            ->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
            ->getQuery()
            ->getResult();

        if (\count($res)) {
            return current($res);
        }

        // then try using hashed_given_url (to use the database index)
        $res = $this->createQueryBuilder('e')
            ->where('e.hashedGivenUrl = :hashed_given_url')->setParameter('hashed_given_url', $hashedUrl)
            ->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
            ->getQuery()
            ->getResult();

        if (\count($res)) {
            return current($res);
        }

        return false;
    }

    /**
     * Count all entries for a user.
     *
     * @param int $userId
     *
     * @return int
     */
    public function countAllEntriesByUser($userId)
    {
        $qb = $this->createQueryBuilder('e')
            ->select('count(e)')
            ->where('e.user = :userId')->setParameter('userId', $userId)
        ;

        return (int) $qb->getQuery()->getSingleScalarResult();
    }

    /**
     * Remove all entries for a user id.
     * Used when a user want to reset all informations.
     *
     * @param int $userId
     */
    public function removeAllByUserId($userId)
    {
        $this->getEntityManager()
            ->createQuery('DELETE FROM Wallabag\CoreBundle\Entity\Entry e WHERE e.user = :userId')
            ->setParameter('userId', $userId)
            ->execute();
    }

    public function removeArchivedByUserId($userId)
    {
        $this->getEntityManager()
            ->createQuery('DELETE FROM Wallabag\CoreBundle\Entity\Entry e WHERE e.user = :userId AND e.isArchived = TRUE')
            ->setParameter('userId', $userId)
            ->execute();
    }

    /**
     * Get id and url from all entries
     * Used for the clean-duplicates command.
     */
    public function findAllEntriesIdAndUrlByUserId($userId)
    {
        $qb = $this->createQueryBuilder('e')
            ->select('e.id, e.url')
            ->where('e.user = :userid')->setParameter(':userid', $userId);

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

    /**
     * @param int $userId
     *
     * @return array
     */
    public function findAllEntriesIdByUserId($userId = null)
    {
        $qb = $this->createQueryBuilder('e')
            ->select('e.id');

        if (null !== $userId) {
            $qb->where('e.user = :userid')->setParameter(':userid', $userId);
        }

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

    /**
     * Find all entries by url and owner.
     *
     * @param string $url
     * @param int    $userId
     *
     * @return array
     */
    public function findAllByUrlAndUserId($url, $userId)
    {
        return $this->createQueryBuilder('e')
            ->where('e.url = :url')->setParameter('url', urldecode($url))
            ->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
            ->getQuery()
            ->getResult();
    }

    /**
     * Returns a random entry, filtering by status.
     *
     * @param int    $userId
     * @param string $type   Can be unread, archive, starred, etc
     *
     * @throws NoResultException
     *
     * @return Entry
     */
    public function getRandomEntry($userId, $type = '')
    {
        $qb = $this->getQueryBuilderByUser($userId)
            ->select('e.id');

        switch ($type) {
            case 'unread':
                $qb->andWhere('e.isArchived = false');
                break;
            case 'archive':
                $qb->andWhere('e.isArchived = true');
                break;
            case 'starred':
                $qb->andWhere('e.isStarred = true');
                break;
            case 'untagged':
                $qb->leftJoin('e.tags', 't');
                $qb->andWhere('t.id is null');
                break;
        }

        $ids = $qb->getQuery()->getArrayResult();

        if (empty($ids)) {
            throw new NoResultException();
        }

        // random select one in the list
        $randomId = $ids[mt_rand(0, \count($ids) - 1)]['id'];

        return $this->find($randomId);
    }

    /**
     * Return a query builder to be used by other getBuilderFor* method.
     *
     * @param int $userId
     *
     * @return QueryBuilder
     */
    private function getQueryBuilderByUser($userId)
    {
        return $this->createQueryBuilder('e')
            ->andWhere('e.user = :userId')->setParameter('userId', $userId);
    }

    /**
     * Return a sorted query builder to be used by other getBuilderFor* method.
     *
     * @param int    $userId
     * @param string $sortBy
     * @param string $direction
     *
     * @return QueryBuilder
     */
    private function getSortedQueryBuilderByUser($userId, $sortBy = 'createdAt', $direction = 'desc')
    {
        return $this->sortQueryBuilder($this->getQueryBuilderByUser($userId), $sortBy, $direction);
    }

    /**
     * Return the given QueryBuilder with an orderBy() call.
     *
     * @param string $sortBy
     * @param string $direction
     *
     * @return QueryBuilder
     */
    private function sortQueryBuilder(QueryBuilder $qb, $sortBy = 'createdAt', $direction = 'desc')
    {
        return $qb->orderBy(sprintf('e.%s', $sortBy), $direction);
    }
}


1			<?php
2
3			namespace Wallabag\CoreBundle\Repository;
4
5			use Doctrine\ORM\EntityRepository;
6			use Doctrine\ORM\NoResultException;
7			use Doctrine\ORM\QueryBuilder;
8			use Pagerfanta\Doctrine\ORM\QueryAdapter as DoctrineORMAdapter;
9			use Pagerfanta\Pagerfanta;
10			use Wallabag\CoreBundle\Entity\Entry;
11			use Wallabag\CoreBundle\Entity\Tag;
12			use Wallabag\CoreBundle\Helper\UrlHasher;
13
14			class EntryRepository extends EntityRepository
15			{
16			/**
17			* Retrieves all entries for a user.
18			*
19			* @param int $userId
20			*
21			* @return QueryBuilder
22			*/
23			public function getBuilderForAllByUser($userId)
24			{
25			return $this
26			->getSortedQueryBuilderByUser($userId)
27			;
28			}
29
30			/**
31			* Retrieves unread entries for a user.
32			*
33			* @param int $userId
34			*
35			* @return QueryBuilder
36			*/
37			public function getBuilderForUnreadByUser($userId)
38			{
39			return $this
40			->getSortedQueryBuilderByUser($userId)
41			->andWhere('e.isArchived = false')
42			;
43			}
44
45			/**
46			* Retrieves read entries for a user.
47			*
48			* @param int $userId
49			*
50			* @return QueryBuilder
51			*/
52			public function getBuilderForArchiveByUser($userId)
53			{
54			return $this
55			->getSortedQueryBuilderByUser($userId, 'archivedAt', 'desc')
56			->andWhere('e.isArchived = true')
57			;
58			}
59
60			/**
61			* Retrieves starred entries for a user.
62			*
63			* @param int $userId
64			*
65			* @return QueryBuilder
66			*/
67			public function getBuilderForStarredByUser($userId)
68			{
69			return $this
70			->getSortedQueryBuilderByUser($userId, 'starredAt', 'desc')
71			->andWhere('e.isStarred = true')
72			;
73			}
74
75			/**
76			* Retrieves entries filtered with a search term for a user.
77			*
78			* @param int $userId
79			* @param string $term
80			* @param string $currentRoute
81			*
82			* @return QueryBuilder
83			*/
84			public function getBuilderForSearchByUser($userId, $term, $currentRoute)
85			{
86			$qb = $this
87			->getSortedQueryBuilderByUser($userId);
88
89			if ('starred' === $currentRoute) {
90			$qb->andWhere('e.isStarred = true');
91			} elseif ('unread' === $currentRoute) {
92			$qb->andWhere('e.isArchived = false');
93			} elseif ('archive' === $currentRoute) {
94			$qb->andWhere('e.isArchived = true');
95			}
96
97			// We lower() all parts here because PostgreSQL 'LIKE' verb is case-sensitive
98			$qb
99			->andWhere('lower(e.content) LIKE lower(:term) OR lower(e.title) LIKE lower(:term) OR lower(e.url) LIKE lower(:term)')->setParameter('term', '%' . $term . '%')
100			->leftJoin('e.tags', 't')
101			->groupBy('e.id');
102
103			return $qb;
104			}
105
106			/**
107			* Retrieve a sorted list of untagged entries for a user.
108			*
109			* @param int $userId
110			*
111			* @return QueryBuilder
112			*/
113			public function getBuilderForUntaggedByUser($userId)
114			{
115			return $this->sortQueryBuilder($this->getRawBuilderForUntaggedByUser($userId));
116			}
117
118			/**
119			* Retrieve untagged entries for a user.
120			*
121			* @param int $userId
122			*
123			* @return QueryBuilder
124			*/
125			public function getRawBuilderForUntaggedByUser($userId)
126			{
127			return $this->getQueryBuilderByUser($userId)
128			->leftJoin('e.tags', 't')
129			->andWhere('t.id is null');
130			}
131
132			/**
133			* Retrieve the number of untagged entries for a user.
134			*
135			* @param int $userId
136			*
137			* @return int
138			*/
139			public function countUntaggedEntriesByUser($userId)
140			{
141			return (int) $this->getRawBuilderForUntaggedByUser($userId)
142			->select('count(e.id)')
143			->getQuery()
144			->getSingleScalarResult();
145			}
146
147			/**
148			* Find Entries.
149			*
150			* @param int $userId
151			* @param bool $isArchived
152			* @param bool $isStarred
153			* @param bool $isPublic
154			* @param string $sort
155			* @param string $order
156			* @param int $since
157			* @param string $tags
158			* @param string $detail 'metadata' or 'full'. Include content field if 'full'
159			*
160			* @todo Breaking change: replace default detail=full by detail=metadata in a future version
161			*
162			* @return Pagerfanta
163			*/
164			public function findEntries($userId, $isArchived = null, $isStarred = null, $isPublic = null, $sort = 'created', $order = 'asc', $since = 0, $tags = '', $detail = 'full')
165			{
166			if (!\in_array(strtolower($detail), ['full', 'metadata'], true)) {
167			throw new \Exception('Detail "' . $detail . '" parameter is wrong, allowed: full or metadata');
168			}
169
170			$qb = $this->createQueryBuilder('e')
171			->leftJoin('e.tags', 't')
172			->where('e.user = :userId')->setParameter('userId', $userId);
173
174			if ('metadata' === $detail) {
175			$fieldNames = $this->getClassMetadata()->getFieldNames();
176			$fields = array_filter($fieldNames, function ($k) {
177			return 'content' !== $k;
178			});
179			$qb->select(sprintf('partial e.{%s}', implode(',', $fields)));
180			}
181
182			if (null !== $isArchived) {
183			$qb->andWhere('e.isArchived = :isArchived')->setParameter('isArchived', (bool) $isArchived);
184			}
185
186			if (null !== $isStarred) {
187			$qb->andWhere('e.isStarred = :isStarred')->setParameter('isStarred', (bool) $isStarred);
188			}
189
190			if (null !== $isPublic) {
191			$qb->andWhere('e.uid IS ' . (true === $isPublic ? 'NOT' : '') . ' NULL');
192			}
193
194			if ($since > 0) {
195			$qb->andWhere('e.updatedAt > :since')->setParameter('since', new \DateTime(date('Y-m-d H:i:s', $since)));
196			}
197
198			if (\is_string($tags) && '' !== $tags) {
199			foreach (explode(',', $tags) as $i => $tag) {
200			$entryAlias = 'e' . $i;
201			$tagAlias = 't' . $i;
202
203			// Complexe queries to ensure multiple tags are associated to an entry
204			// https://stackoverflow.com/a/6638146/569101
205			$qb->andWhere($qb->expr()->in(
206			'e.id',
207			$this->createQueryBuilder($entryAlias)
208			->select($entryAlias . '.id')
209			->leftJoin($entryAlias . '.tags', $tagAlias)
210			->where($tagAlias . '.label = :label' . $i)
211			->getDQL()
212			));
213
214			// bound parameter to the main query builder
215			$qb->setParameter('label' . $i, $tag);
216			}
217			}
218
219			if (!\in_array(strtolower($order), ['asc', 'desc'], true)) {
220			throw new \Exception('Order "' . $order . '" parameter is wrong, allowed: asc or desc');
221			}
222
223			if ('created' === $sort) {
224			$qb->orderBy('e.id', $order);
225			} elseif ('updated' === $sort) {
226			$qb->orderBy('e.updatedAt', $order);
227			} elseif ('archived' === $sort) {
228			$qb->orderBy('e.archivedAt', $order);
229			}
230
231			$pagerAdapter = new DoctrineORMAdapter($qb, true, false);
232
233			return new Pagerfanta($pagerAdapter);
234			}
235
236			/**
237			* Fetch an entry with a tag. Only used for tests.
238			*
239			* @param int $userId
240			*
241			* @return array
242			*/
243			public function findOneWithTags($userId)
244			{
245			$qb = $this->createQueryBuilder('e')
246			->innerJoin('e.tags', 't')
247			->innerJoin('e.user', 'u')
248			->addSelect('t', 'u')
249			->where('e.user = :userId')->setParameter('userId', $userId)
250			;
251
252			return $qb->getQuery()->getResult();
253			}
254
255			/**
256			* Find distinct language for a given user.
257			* Used to build the filter language list.
258			*
259			* @param int $userId User id
260			*
261			* @return array
262			*/
263			public function findDistinctLanguageByUser($userId)
264			{
265			$results = $this->createQueryBuilder('e')
266			->select('e.language')
267			->where('e.user = :userId')->setParameter('userId', $userId)
268			->andWhere('e.language IS NOT NULL')
269			->groupBy('e.language')
270			->orderBy('e.language', ' ASC')
271			->getQuery()
272			->getResult();
273
274			$languages = [];
275			foreach ($results as $result) {
276			$languages[$result['language']] = $result['language'];
277			}
278
279			return $languages;
280			}
281
282			/**
283			* Used only in test case to get the right entry associated to the right user.
284			*
285			* @param string $username
286			*
287			* @return Entry
288			*/
289			public function findOneByUsernameAndNotArchived($username)
290			{
291			return $this->createQueryBuilder('e')
292			->leftJoin('e.user', 'u')
293			->where('u.username = :username')->setParameter('username', $username)
294			->andWhere('e.isArchived = false')
295			->setMaxResults(1)
296			->getQuery()
297			->getSingleResult();
298			}
299
300			/**
301			* Remove a tag from all user entries.
302			*
303			* We need to loop on each entry attached to the given tag to remove it, since Doctrine doesn't know EntryTag entity because it's a ManyToMany relation.
304			* It could be faster with one query but I don't know how to retrieve the table name `entry_tag` which can have a prefix:
305			*
306			* DELETE et FROM entry_tag et WHERE et.entry_id IN ( SELECT e.id FROM entry e WHERE e.user_id = :userId ) AND et.tag_id = :tagId
307			*
308			* @param int $userId
309			*/
310			public function removeTag($userId, Tag $tag)
311			{
312			$entries = $this->getSortedQueryBuilderByUser($userId)
313			->innerJoin('e.tags', 't')
314			->andWhere('t.id = :tagId')->setParameter('tagId', $tag->getId())
315			->getQuery()
316			->getResult();
317
318			foreach ($entries as $entry) {
319			$entry->removeTag($tag);
320			}
321
322			$this->getEntityManager()->flush();
323			}
324
325			/**
326			* Remove tags from all user entries.
327			*
328			* @param int $userId
329			* @param Array<Tag> $tags
330			*/
331			public function removeTags($userId, $tags)
332			{
333			foreach ($tags as $tag) {
334			$this->removeTag($userId, $tag);
335			}
336			}
337
338			/**
339			* Find all entries that are attached to a give tag id.
340			*
341			* @param int $userId
342			* @param int $tagId
343			*
344			* @return array
345			*/
346			public function findAllByTagId($userId, $tagId)
347			{
348			return $this->getSortedQueryBuilderByUser($userId)
349			->innerJoin('e.tags', 't')
350			->andWhere('t.id = :tagId')->setParameter('tagId', $tagId)
351			->getQuery()
352			->getResult();
353			}
354
355			/**
356			* Find an entry by its url and its owner.
357			* If it exists, return the entry otherwise return false.
358			*
359			* @param string $url
360			* @param int $userId
361			*
362			* @return Entry\|false
363			*/
364			public function findByUrlAndUserId($url, $userId)
365			{
366			return $this->findByHashedUrlAndUserId(
367			UrlHasher::hashUrl($url),
368			$userId
369			);
370			}
371
372			/**
373			* Find all entries which have an empty value for hash.
374			*
375			* @return Entry\|false
376			*/
377			public function findByEmptyHashedUrlAndUserId(int $userId)
378			{
379			return $this->createQueryBuilder('e')
			0 ignored issues – show Bug Best Practice introduced 2020-12-18 15:36 UTC by Report Bug Copy Issue Report The expression `return $this->createQuer...getQuery()->getResult()` also could return the type `array` which is incompatible with the documented return type `Wallabag\CoreBundle\Entity\Entry\|false`. Loading history...
380			->where('e.hashedUrl = :empty')->setParameter('empty', '')
381			->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
382			->getQuery()
383			->getResult();
384			}
385
386			/**
387			* Find an entry by its hashed url and its owner.
388			* If it exists, return the entry otherwise return false.
389			*
390			* @param string $hashedUrl Url hashed using sha1
391			* @param int $userId
392			*
393			* @return Entry\|false
394			*/
395			public function findByHashedUrlAndUserId($hashedUrl, $userId)
396			{
397			// try first using hashed_url (to use the database index)
398			$res = $this->createQueryBuilder('e')
399			->where('e.hashedUrl = :hashed_url')->setParameter('hashed_url', $hashedUrl)
400			->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
401			->getQuery()
402			->getResult();
403
404			if (\count($res)) {
405			return current($res);
406			}
407
408			// then try using hashed_given_url (to use the database index)
409			$res = $this->createQueryBuilder('e')
410			->where('e.hashedGivenUrl = :hashed_given_url')->setParameter('hashed_given_url', $hashedUrl)
411			->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
412			->getQuery()
413			->getResult();
414
415			if (\count($res)) {
416			return current($res);
417			}
418
419			return false;
420			}
421
422			/**
423			* Count all entries for a user.
424			*
425			* @param int $userId
426			*
427			* @return int
428			*/
429			public function countAllEntriesByUser($userId)
430			{
431			$qb = $this->createQueryBuilder('e')
432			->select('count(e)')
433			->where('e.user = :userId')->setParameter('userId', $userId)
434			;
435
436			return (int) $qb->getQuery()->getSingleScalarResult();
437			}
438
439			/**
440			* Remove all entries for a user id.
441			* Used when a user want to reset all informations.
442			*
443			* @param int $userId
444			*/
445			public function removeAllByUserId($userId)
446			{
447			$this->getEntityManager()
448			->createQuery('DELETE FROM Wallabag\CoreBundle\Entity\Entry e WHERE e.user = :userId')
449			->setParameter('userId', $userId)
450			->execute();
451			}
452
453			public function removeArchivedByUserId($userId)
454			{
455			$this->getEntityManager()
456			->createQuery('DELETE FROM Wallabag\CoreBundle\Entity\Entry e WHERE e.user = :userId AND e.isArchived = TRUE')
457			->setParameter('userId', $userId)
458			->execute();
459			}
460
461			/**
462			* Get id and url from all entries
463			* Used for the clean-duplicates command.
464			*/
465			public function findAllEntriesIdAndUrlByUserId($userId)
466			{
467			$qb = $this->createQueryBuilder('e')
468			->select('e.id, e.url')
469			->where('e.user = :userid')->setParameter(':userid', $userId);
470
471			return $qb->getQuery()->getArrayResult();
472			}
473
474			/**
475			* @param int $userId
476			*
477			* @return array
478			*/
479			public function findAllEntriesIdByUserId($userId = null)
480			{
481			$qb = $this->createQueryBuilder('e')
482			->select('e.id');
483
484			if (null !== $userId) {
485			$qb->where('e.user = :userid')->setParameter(':userid', $userId);
486			}
487
488			return $qb->getQuery()->getArrayResult();
489			}
490
491			/**
492			* Find all entries by url and owner.
493			*
494			* @param string $url
495			* @param int $userId
496			*
497			* @return array
498			*/
499			public function findAllByUrlAndUserId($url, $userId)
500			{
501			return $this->createQueryBuilder('e')
502			->where('e.url = :url')->setParameter('url', urldecode($url))
503			->andWhere('e.user = :user_id')->setParameter('user_id', $userId)
504			->getQuery()
505			->getResult();
506			}
507
508			/**
509			* Returns a random entry, filtering by status.
510			*
511			* @param int $userId
512			* @param string $type Can be unread, archive, starred, etc
513			*
514			* @throws NoResultException
515			*
516			* @return Entry
517			*/
518			public function getRandomEntry($userId, $type = '')
519			{
520			$qb = $this->getQueryBuilderByUser($userId)
521			->select('e.id');
522
523			switch ($type) {
524			case 'unread':
525			$qb->andWhere('e.isArchived = false');
526			break;
527			case 'archive':
528			$qb->andWhere('e.isArchived = true');
529			break;
530			case 'starred':
531			$qb->andWhere('e.isStarred = true');
532			break;
533			case 'untagged':
534			$qb->leftJoin('e.tags', 't');
535			$qb->andWhere('t.id is null');
536			break;
537			}
538
539			$ids = $qb->getQuery()->getArrayResult();
540
541			if (empty($ids)) {
542			throw new NoResultException();
543			}
544
545			// random select one in the list
546			$randomId = $ids[mt_rand(0, \count($ids) - 1)]['id'];
547
548			return $this->find($randomId);
549			}
550
551			/**
552			* Return a query builder to be used by other getBuilderFor* method.
553			*
554			* @param int $userId
555			*
556			* @return QueryBuilder
557			*/
558			private function getQueryBuilderByUser($userId)
559			{
560			return $this->createQueryBuilder('e')
561			->andWhere('e.user = :userId')->setParameter('userId', $userId);
562			}
563
564			/**
565			* Return a sorted query builder to be used by other getBuilderFor* method.
566			*
567			* @param int $userId
568			* @param string $sortBy
569			* @param string $direction
570			*
571			* @return QueryBuilder
572			*/
573			private function getSortedQueryBuilderByUser($userId, $sortBy = 'createdAt', $direction = 'desc')
574			{
575			return $this->sortQueryBuilder($this->getQueryBuilderByUser($userId), $sortBy, $direction);
576			}
577
578			/**
579			* Return the given QueryBuilder with an orderBy() call.
580			*
581			* @param string $sortBy
582			* @param string $direction
583			*
584			* @return QueryBuilder
585			*/
586			private function sortQueryBuilder(QueryBuilder $qb, $sortBy = 'createdAt', $direction = 'desc')
587			{
588			return $qb->orderBy(sprintf('e.%s', $sortBy), $direction);
589			}
590			}
591

wallabag / wallabag

Push — master ( d20139...863dd6 )

EntryRepository::findByEmptyHashedUrlAndUserId() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like