RaCandidateRepository::createSearchQuery() - Code Metrics - Inspection of "Fix authorization filter" - OpenConext/Stepup-Middleware - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#261)

unknown

created 2019-01-25 16:18 UTC

RaCandidateRepository::createSearchQuery() A

↳ Parent: RaCandidateRepository

Complexity

Conditions	5
Paths	16

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	36
rs	9.0328
c	0
b	0
f	0
cc	5
nc	16
nop	1

<?php

/**
 * Copyright 2014 SURFnet bv
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Surfnet\StepupMiddleware\ApiBundle\Identity\Repository;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Query\Expr\Join;
use Surfnet\Stepup\Identity\Collection\InstitutionCollection;
use Surfnet\Stepup\Identity\Value\IdentityId;
use Surfnet\Stepup\Identity\Value\Institution;
use Surfnet\StepupMiddleware\ApiBundle\Authorization\Filter\InstitutionAuthorizationRepositoryFilter;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\RaCandidate;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\VettedSecondFactor;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Query\RaCandidateQuery;

/**
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 */
class RaCandidateRepository extends EntityRepository
{
    /**
     * @var InstitutionAuthorizationRepositoryFilter
     */
    private $authorizationRepositoryFilter;

    public function __construct(
        EntityManager $em,
        Mapping\ClassMetadata $class,
        InstitutionAuthorizationRepositoryFilter $authorizationRepositoryFilter
    ) {
        parent::__construct($em, $class);
        $this->authorizationRepositoryFilter = $authorizationRepositoryFilter;
    }

    /**
     * @param RaCandidate $raCandidate
     * @return void
     */
    public function merge(RaCandidate $raCandidate)
    {
        $raCandidate = $this->getEntityManager()->merge($raCandidate);
        $this->getEntityManager()->persist($raCandidate);
        $this->getEntityManager()->flush();
    }

    /**
     * @param IdentityId $identityId
     * @return void
     */
    public function removeByIdentityId(IdentityId $identityId)
    {
        $raCandidate = $this->findByIdentityId($identityId);

        if (!$raCandidate) {
            return;
        }

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

    /**
     * @param Institution $institution
     * @param InstitutionCollection $raInstitutions
     * @return void
     */
    public function removeInstitutionsNotInList(Institution $institution, InstitutionCollection $raInstitutions)
    {
        $raCandidates = $this->createQueryBuilder('rac')
            ->where('rac.raInstitution = :raInstitution')
            ->andWhere('rac.institution NOT IN (:institutions)')
            ->setParameter('raInstitution', $institution)
            ->setParameter('institutions', $raInstitutions->serialize())
            ->getQuery()
            ->getResult();

        $em = $this->getEntityManager();
        foreach ($raCandidates as $raCandidate) {
            $em->remove($raCandidate);
        }

        $em->flush();
    }

    /**
     * @param Institution $raInstitution
     * @return void
     */
    public function removeByRaInstitution(Institution $raInstitution)
    {
        $raCandidates = $this->findByRaInstitution($raInstitution);

        if (empty($raCandidates)) {
            return;
        }

        $em = $this->getEntityManager();
        foreach ($raCandidates as $raCandidate) {
            $em->remove($raCandidate);
        }

        $em->flush();
    }

    /**
     * @param IdentityId $identityId
     * @param Institution $raInstitution
     * @return void
     */
    public function removeByIdentityIdAndRaInstitution(IdentityId $identityId, Institution $raInstitution)
    {
        $raCandidate = $this->findByIdentityIdAndRaInstitution($identityId, $raInstitution);

        if (!$raCandidate) {
            return;
        }
        $em = $this->getEntityManager();
        $em->remove($raCandidate);
        $em->flush();
    }

    /**
     * @param string[] $nameIds
     * @return void
     */
    public function removeByNameIds($nameIds)
    {
        $raCandidates = $this->findByNameIds($nameIds);

        $em = $this->getEntityManager();
        foreach ($raCandidates as $raCandidate) {
            $em->remove($raCandidate);
        }

        $em->flush();
    }

    /**
     * @param RaCandidateQuery $query
     * @return \Doctrine\ORM\Query
     */
    public function createSearchQuery(RaCandidateQuery $query)
    {
        $queryBuilder = $this->createQueryBuilder('rac');

        // Modify query to filter on authorization
        $queryBuilder
            ->andWhere('rac.raInstitution = :raInstitution')
            ->setParameter('raInstitution', $query->authorizationContext->getActorInstitution());

        if ($query->institution) {
            $queryBuilder
                ->andWhere('rac.institution = :institution')
                ->setParameter('institution', $query->institution);
        }

        if ($query->commonName) {
            $queryBuilder
                ->andWhere('MATCH_AGAINST(rac.commonName, :commonName) > 0')
                ->setParameter('commonName', $query->commonName);
        }

        if ($query->email) {
            $queryBuilder
                ->andWhere('MATCH_AGAINST(rac.email, :email) > 0')
                ->setParameter('email', $query->email);
        }

        if (!empty($query->secondFactorTypes)) {
            $queryBuilder
                ->innerJoin(VettedSecondFactor::class, 'vsf', Join::WITH, 'rac.identityId = vsf.identityId')
                ->andWhere('vsf.type IN (:secondFactorTypes)')
                ->setParameter('secondFactorTypes', $query->secondFactorTypes);
        }

        return $queryBuilder->getQuery();
    }

    /**
     * @param string[] $sraaList
     * @return RaCandidate[]
     */
    public function findByNameIds(array $sraaList)
    {
        return $this->createQueryBuilder('rac')
            ->where('rac.nameId IN (:sraaList)')
            ->setParameter('sraaList', $sraaList)
            ->getQuery()
            ->getResult();
    }

    /**
     * @param string $identityId
     * @return null|RaCandidate
     * @throws \Doctrine\ORM\NonUniqueResultException
     */
    public function findByIdentityId($identityId)
    {
        return $this->createQueryBuilder('rac')
            ->where('rac.identityId = :identityId')
            ->setParameter('identityId', $identityId)
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @param string $identityId
     * @param Institution $raInstitution
     * @return null|RaCandidate
     * @throws \Doctrine\ORM\NonUniqueResultException
     */
    public function findByIdentityIdAndRaInstitution($identityId, Institution $raInstitution)
    {
        return $this->createQueryBuilder('rac')
            ->where('rac.identityId = :identityId')
            ->andWhere('rac.raInstitution = :raInstitution')
            ->setParameter('identityId', $identityId)
            ->setParameter('raInstitution', $raInstitution)
            ->getQuery()
            ->getOneOrNullResult();
    }

    /**
     * @param Institution $raInstitution
     * @return ArrayCollection|RaCandidate[]

     * @throws \Doctrine\ORM\NonUniqueResultException
     */
    public function findByRaInstitution(Institution $raInstitution)
    {
        return $this->createQueryBuilder('rac')
            ->where('rac.raInstitution = :raInstitution')
            ->setParameter('raInstitution', $raInstitution)
            ->getQuery()
            ->getResult();
    }
}


1			<?php
2
3			/**
4			* Copyright 2014 SURFnet bv
5			*
6			* Licensed under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License.
8			* You may obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS,
14			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15			* See the License for the specific language governing permissions and
16			* limitations under the License.
17			*/
18
19			namespace Surfnet\StepupMiddleware\ApiBundle\Identity\Repository;
20
21			use Doctrine\Common\Collections\ArrayCollection;
22			use Doctrine\ORM\Mapping;
23			use Doctrine\ORM\EntityManager;
24			use Doctrine\ORM\EntityRepository;
25			use Doctrine\ORM\Query\Expr\Join;
26			use Surfnet\Stepup\Identity\Collection\InstitutionCollection;
27			use Surfnet\Stepup\Identity\Value\IdentityId;
28			use Surfnet\Stepup\Identity\Value\Institution;
29			use Surfnet\StepupMiddleware\ApiBundle\Authorization\Filter\InstitutionAuthorizationRepositoryFilter;
30			use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\RaCandidate;
31			use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\VettedSecondFactor;
32			use Surfnet\StepupMiddleware\ApiBundle\Identity\Query\RaCandidateQuery;
33
34			/**
35			* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
36			* @SuppressWarnings(PHPMD.TooManyPublicMethods)
37			*/
38			class RaCandidateRepository extends EntityRepository
39			{
40			/**
41			* @var InstitutionAuthorizationRepositoryFilter
42			*/
43			private $authorizationRepositoryFilter;
44
45			public function __construct(
46			EntityManager $em,
47			Mapping\ClassMetadata $class,
48			InstitutionAuthorizationRepositoryFilter $authorizationRepositoryFilter
49			) {
50			parent::__construct($em, $class);
51			$this->authorizationRepositoryFilter = $authorizationRepositoryFilter;
52			}
53
54			/**
55			* @param RaCandidate $raCandidate
56			* @return void
57			*/
58			public function merge(RaCandidate $raCandidate)
59			{
60			$raCandidate = $this->getEntityManager()->merge($raCandidate);
61			$this->getEntityManager()->persist($raCandidate);
62			$this->getEntityManager()->flush();
63			}
64
65			/**
66			* @param IdentityId $identityId
67			* @return void
68			*/
69			public function removeByIdentityId(IdentityId $identityId)
70			{
71			$raCandidate = $this->findByIdentityId($identityId);
72
73			if (!$raCandidate) {
74			return;
75			}
76
77			$this->getEntityManager()->remove($raCandidate);
78			$this->getEntityManager()->flush();
79			}
80
81			/**
82			* @param Institution $institution
83			* @param InstitutionCollection $raInstitutions
84			* @return void
85			*/
86			public function removeInstitutionsNotInList(Institution $institution, InstitutionCollection $raInstitutions)
87			{
88			$raCandidates = $this->createQueryBuilder('rac')
89			->where('rac.raInstitution = :raInstitution')
90			->andWhere('rac.institution NOT IN (:institutions)')
91			->setParameter('raInstitution', $institution)
92			->setParameter('institutions', $raInstitutions->serialize())
93			->getQuery()
94			->getResult();
95
96			$em = $this->getEntityManager();
97			foreach ($raCandidates as $raCandidate) {
98			$em->remove($raCandidate);
99			}
100
101			$em->flush();
102			}
103
104			/**
105			* @param Institution $raInstitution
106			* @return void
107			*/
108			public function removeByRaInstitution(Institution $raInstitution)
109			{
110			$raCandidates = $this->findByRaInstitution($raInstitution);
111
112			if (empty($raCandidates)) {
113			return;
114			}
115
116			$em = $this->getEntityManager();
117			foreach ($raCandidates as $raCandidate) {
118			$em->remove($raCandidate);
119			}
120
121			$em->flush();
122			}
123
124			/**
125			* @param IdentityId $identityId
126			* @param Institution $raInstitution
127			* @return void
128			*/
129			public function removeByIdentityIdAndRaInstitution(IdentityId $identityId, Institution $raInstitution)
130			{
131			$raCandidate = $this->findByIdentityIdAndRaInstitution($identityId, $raInstitution);
132
133			if (!$raCandidate) {
134			return;
135			}
136			$em = $this->getEntityManager();
137			$em->remove($raCandidate);
138			$em->flush();
139			}
140
141			/**
142			* @param string[] $nameIds
143			* @return void
144			*/
145			public function removeByNameIds($nameIds)
146			{
147			$raCandidates = $this->findByNameIds($nameIds);
148
149			$em = $this->getEntityManager();
150			foreach ($raCandidates as $raCandidate) {
151			$em->remove($raCandidate);
152			}
153
154			$em->flush();
155			}
156
157			/**
158			* @param RaCandidateQuery $query
159			* @return \Doctrine\ORM\Query
160			*/
161			public function createSearchQuery(RaCandidateQuery $query)
162			{
163			$queryBuilder = $this->createQueryBuilder('rac');
164
165			// Modify query to filter on authorization
166			$queryBuilder
167			->andWhere('rac.raInstitution = :raInstitution')
168			->setParameter('raInstitution', $query->authorizationContext->getActorInstitution());
169
170			if ($query->institution) {
171			$queryBuilder
172			->andWhere('rac.institution = :institution')
173			->setParameter('institution', $query->institution);
174			}
175
176			if ($query->commonName) {
177			$queryBuilder
178			->andWhere('MATCH_AGAINST(rac.commonName, :commonName) > 0')
179			->setParameter('commonName', $query->commonName);
180			}
181
182			if ($query->email) {
183			$queryBuilder
184			->andWhere('MATCH_AGAINST(rac.email, :email) > 0')
185			->setParameter('email', $query->email);
186			}
187
188			if (!empty($query->secondFactorTypes)) {
189			$queryBuilder
190			->innerJoin(VettedSecondFactor::class, 'vsf', Join::WITH, 'rac.identityId = vsf.identityId')
191			->andWhere('vsf.type IN (:secondFactorTypes)')
192			->setParameter('secondFactorTypes', $query->secondFactorTypes);
193			}
194
195			return $queryBuilder->getQuery();
196			}
197
198			/**
199			* @param string[] $sraaList
200			* @return RaCandidate[]
201			*/
202			public function findByNameIds(array $sraaList)
203			{
204			return $this->createQueryBuilder('rac')
205			->where('rac.nameId IN (:sraaList)')
206			->setParameter('sraaList', $sraaList)
207			->getQuery()
208			->getResult();
209			}
210
211			/**
212			* @param string $identityId
213			* @return null\|RaCandidate
214			* @throws \Doctrine\ORM\NonUniqueResultException
215			*/
216			public function findByIdentityId($identityId)
217			{
218			return $this->createQueryBuilder('rac')
219			->where('rac.identityId = :identityId')
220			->setParameter('identityId', $identityId)
221			->getQuery()
222			->getOneOrNullResult();
223			}
224
225			/**
226			* @param string $identityId
227			* @param Institution $raInstitution
228			* @return null\|RaCandidate
229			* @throws \Doctrine\ORM\NonUniqueResultException
230			*/
231			public function findByIdentityIdAndRaInstitution($identityId, Institution $raInstitution)
232			{
233			return $this->createQueryBuilder('rac')
234			->where('rac.identityId = :identityId')
235			->andWhere('rac.raInstitution = :raInstitution')
236			->setParameter('identityId', $identityId)
237			->setParameter('raInstitution', $raInstitution)
238			->getQuery()
239			->getOneOrNullResult();
240			}
241
242			/**
243			* @param Institution $raInstitution
244			* @return ArrayCollection\|RaCandidate[]
			0 ignored issues – show Documentation introduced 2018-10-23 15:28 UTC by Report Bug Copy Issue Report Should the return type not be `array`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
245			* @throws \Doctrine\ORM\NonUniqueResultException
246			*/
247			public function findByRaInstitution(Institution $raInstitution)
248			{
249			return $this->createQueryBuilder('rac')
250			->where('rac.raInstitution = :raInstitution')
251			->setParameter('raInstitution', $raInstitution)
252			->getQuery()
253			->getResult();
254			}
255			}
256

OpenConext / Stepup-Middleware

Pull Request — develop (#261)

RaCandidateRepository::createSearchQuery() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like