RaCandidateRepository::removeInstitutionsNotInList() - Code Metrics - Inspection of "Fix RA removal when token gets removed" - OpenConext/Stepup-Middleware - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/fix-token-ra-candiate-... ( 57b9ef...288fa0 )

unknown

created 2019-07-30 14:08 UTC

removeInstitutionsNotInList() A

↳ Parent: RaCandidateRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
c	0
b	0
f	0
rs	9.7
cc	2
nc	2
nop	2

<?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\EntityManager;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Mapping;
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\Authorization\Value\InstitutionAuthorizationContextInterface;
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)
    {
        $raCandidates = $this->findByIdentityId($identityId);

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

        foreach ($raCandidates as $candidate) {
            $this->getEntityManager()->remove($candidate);
        }
        $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
        $this->authorizationRepositoryFilter->filter(
            $queryBuilder,
            $query->authorizationContext,
            'rac.raInstitution',
            'iac'
        );

        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);
        }

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

        $queryBuilder->groupBy('rac.identityId');

        return $queryBuilder->getQuery();
    }

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

        // Modify query to filter on authorization
        $this->authorizationRepositoryFilter->filter(
            $queryBuilder,
            $query->authorizationContext,
            'rac.raInstitution',
            'iac'
        );

        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 RaCandidate[]
     * @throws \Doctrine\ORM\NonUniqueResultException
     */
    public function findByIdentityId($identityId)
    {
        return $this->createQueryBuilder('rac')
            ->where('rac.identityId = :identityId')
            ->setParameter('identityId', $identityId)
            ->getQuery()
            ->getResult();
    }

    /**
     * @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 string $identityId
     * @param InstitutionAuthorizationContextInterface $authorizationContext
     * @return RaCandidate[]
     */
    public function findAllRaasByIdentityId($identityId, InstitutionAuthorizationContextInterface $authorizationContext)
    {
        $queryBuilder = $this->createQueryBuilder('rac')
            ->where('rac.identityId = :identityId')
            ->setParameter('identityId', $identityId)
            ->orderBy('rac.raInstitution');

        // Modify query to filter on authorization
        $this->authorizationRepositoryFilter->filter(
            $queryBuilder,
            $authorizationContext,
            'rac.raInstitution',
            'iac'
        );

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

    /**
     * @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\EntityManager;
23			use Doctrine\ORM\EntityRepository;
24			use Doctrine\ORM\Mapping;
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\Authorization\Value\InstitutionAuthorizationContextInterface;
31			use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\RaCandidate;
32			use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\VettedSecondFactor;
33			use Surfnet\StepupMiddleware\ApiBundle\Identity\Query\RaCandidateQuery;
34
35			/**
36			* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
37			* @SuppressWarnings(PHPMD.TooManyPublicMethods)
38			*/
39			class RaCandidateRepository extends EntityRepository
40			{
41			/**
42			* @var InstitutionAuthorizationRepositoryFilter
43			*/
44			private $authorizationRepositoryFilter;
45
46			public function __construct(
47			EntityManager $em,
48			Mapping\ClassMetadata $class,
49			InstitutionAuthorizationRepositoryFilter $authorizationRepositoryFilter
50			) {
51			parent::__construct($em, $class);
52			$this->authorizationRepositoryFilter = $authorizationRepositoryFilter;
53			}
54
55			/**
56			* @param RaCandidate $raCandidate
57			* @return void
58			*/
59			public function merge(RaCandidate $raCandidate)
60			{
61			$raCandidate = $this->getEntityManager()->merge($raCandidate);
62			$this->getEntityManager()->persist($raCandidate);
63			$this->getEntityManager()->flush();
64			}
65
66			/**
67			* @param IdentityId $identityId
68			* @return void
69			*/
70			public function removeByIdentityId(IdentityId $identityId)
71			{
72			$raCandidates = $this->findByIdentityId($identityId);
73
74			if (empty($raCandidates)) {
75			return;
76			}
77
78			foreach ($raCandidates as $candidate) {
79			$this->getEntityManager()->remove($candidate);
80			}
81			$this->getEntityManager()->flush();
82			}
83
84			/**
85			* @param Institution $institution
86			* @param InstitutionCollection $raInstitutions
87			* @return void
88			*/
89			public function removeInstitutionsNotInList(Institution $institution, InstitutionCollection $raInstitutions)
90			{
91			$raCandidates = $this->createQueryBuilder('rac')
92			->where('rac.raInstitution = :raInstitution')
93			->andWhere('rac.institution NOT IN (:institutions)')
94			->setParameter('raInstitution', $institution)
95			->setParameter('institutions', $raInstitutions->serialize())
96			->getQuery()
97			->getResult();
98
99			$em = $this->getEntityManager();
100			foreach ($raCandidates as $raCandidate) {
101			$em->remove($raCandidate);
102			}
103
104			$em->flush();
105			}
106
107			/**
108			* @param Institution $raInstitution
109			* @return void
110			*/
111			public function removeByRaInstitution(Institution $raInstitution)
112			{
113			$raCandidates = $this->findByRaInstitution($raInstitution);
114
115			if (empty($raCandidates)) {
116			return;
117			}
118
119			$em = $this->getEntityManager();
120			foreach ($raCandidates as $raCandidate) {
121			$em->remove($raCandidate);
122			}
123
124			$em->flush();
125			}
126
127			/**
128			* @param IdentityId $identityId
129			* @param Institution $raInstitution
130			* @return void
131			*/
132			public function removeByIdentityIdAndRaInstitution(IdentityId $identityId, Institution $raInstitution)
133			{
134			$raCandidate = $this->findByIdentityIdAndRaInstitution($identityId, $raInstitution);
135
136			if (!$raCandidate) {
137			return;
138			}
139			$em = $this->getEntityManager();
140			$em->remove($raCandidate);
141			$em->flush();
142			}
143
144			/**
145			* @param string[] $nameIds
146			* @return void
147			*/
148			public function removeByNameIds($nameIds)
149			{
150			$raCandidates = $this->findByNameIds($nameIds);
151
152			$em = $this->getEntityManager();
153			foreach ($raCandidates as $raCandidate) {
154			$em->remove($raCandidate);
155			}
156
157			$em->flush();
158			}
159
160			/**
161			* @param RaCandidateQuery $query
162			* @return \Doctrine\ORM\Query
163			*/
164			public function createSearchQuery(RaCandidateQuery $query)
165			{
166			$queryBuilder = $this->createQueryBuilder('rac');
167
168			// Modify query to filter on authorization
169			$this->authorizationRepositoryFilter->filter(
170			$queryBuilder,
171			$query->authorizationContext,
172			'rac.raInstitution',
173			'iac'
174			);
175
176			if ($query->institution) {
177			$queryBuilder
178			->andWhere('rac.institution = :institution')
179			->setParameter('institution', $query->institution);
180			}
181
182			if ($query->commonName) {
183			$queryBuilder
184			->andWhere('MATCH_AGAINST(rac.commonName, :commonName) > 0')
185			->setParameter('commonName', $query->commonName);
186			}
187
188			if ($query->email) {
189			$queryBuilder
190			->andWhere('MATCH_AGAINST(rac.email, :email) > 0')
191			->setParameter('email', $query->email);
192			}
193
194			if (!empty($query->secondFactorTypes)) {
195			$queryBuilder
196			->innerJoin(VettedSecondFactor::class, 'vsf', Join::WITH, 'rac.identityId = vsf.identityId')
197			->andWhere('vsf.type IN (:secondFactorTypes)')
198			->setParameter('secondFactorTypes', $query->secondFactorTypes);
199			}
200
201			if (!empty($query->raInstitution)) {
202			$queryBuilder
203			->andWhere('rac.raInstitution = :raInstitution')
204			->setParameter('raInstitution', $query->raInstitution);
205			}
206
207			$queryBuilder->groupBy('rac.identityId');
208
209			return $queryBuilder->getQuery();
210			}
211
212			/**
213			* @param RaCandidateQuery $query
214			* @return \Doctrine\ORM\Query
215			*/
216			public function createOptionsQuery(RaCandidateQuery $query)
217			{
218			$queryBuilder = $this->createQueryBuilder('rac')
219			->select('rac.institution')
220			->groupBy('rac.institution');
221
222			// Modify query to filter on authorization
223			$this->authorizationRepositoryFilter->filter(
224			$queryBuilder,
225			$query->authorizationContext,
226			'rac.raInstitution',
227			'iac'
228			);
229
230			return $queryBuilder->getQuery();
231			}
232
233			/**
234			* @param string[] $sraaList
235			* @return RaCandidate[]
236			*/
237			public function findByNameIds(array $sraaList)
238			{
239			return $this->createQueryBuilder('rac')
240			->where('rac.nameId IN (:sraaList)')
241			->setParameter('sraaList', $sraaList)
242			->getQuery()
243			->getResult();
244			}
245
246			/**
247			* @param string $identityId
248			* @return RaCandidate[]
249			* @throws \Doctrine\ORM\NonUniqueResultException
250			*/
251			public function findByIdentityId($identityId)
252			{
253			return $this->createQueryBuilder('rac')
254			->where('rac.identityId = :identityId')
255			->setParameter('identityId', $identityId)
256			->getQuery()
257			->getResult();
258			}
259
260			/**
261			* @param string $identityId
262			* @param Institution $raInstitution
263			* @return null\|RaCandidate
264			* @throws \Doctrine\ORM\NonUniqueResultException
265			*/
266			public function findByIdentityIdAndRaInstitution($identityId, Institution $raInstitution)
267			{
268			return $this->createQueryBuilder('rac')
269			->where('rac.identityId = :identityId')
270			->andWhere('rac.raInstitution = :raInstitution')
271			->setParameter('identityId', $identityId)
272			->setParameter('raInstitution', $raInstitution)
273			->getQuery()
274			->getOneOrNullResult();
275			}
276
277			/**
278			* @param string $identityId
279			* @param InstitutionAuthorizationContextInterface $authorizationContext
280			* @return RaCandidate[]
281			*/
282			public function findAllRaasByIdentityId($identityId, InstitutionAuthorizationContextInterface $authorizationContext)
283			{
284			$queryBuilder = $this->createQueryBuilder('rac')
285			->where('rac.identityId = :identityId')
286			->setParameter('identityId', $identityId)
287			->orderBy('rac.raInstitution');
288
289			// Modify query to filter on authorization
290			$this->authorizationRepositoryFilter->filter(
291			$queryBuilder,
292			$authorizationContext,
293			'rac.raInstitution',
294			'iac'
295			);
296
297			return $queryBuilder->getQuery()->getResult();
298			}
299
300			/**
301			* @param Institution $raInstitution
302			* @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...
303			* @throws \Doctrine\ORM\NonUniqueResultException
304			*/
305			public function findByRaInstitution(Institution $raInstitution)
306			{
307			return $this->createQueryBuilder('rac')
308			->where('rac.raInstitution = :raInstitution')
309			->setParameter('raInstitution', $raInstitution)
310			->getQuery()
311			->getResult();
312			}
313			}
314

OpenConext / Stepup-Middleware

Push — feature/fix-token-ra-candiate-... ( 57b9ef...288fa0 )

removeInstitutionsNotInList() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like