IdentityRepository::find() - Code Metrics - Inspection of "Fine grained authorization" - OpenConext/Stepup-Middleware - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#256)

unknown

created 2019-01-09 09:37 UTC

IdentityRepository::find() A

↳ Parent: IdentityRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	10
c	0
b	0
f	0
cc	1
nc	1
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\EntityManager;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Mapping;
use Surfnet\Stepup\Identity\Value\IdentityId;
use Surfnet\Stepup\Identity\Value\Institution;
use Surfnet\Stepup\Identity\Value\NameId;
use Surfnet\StepupMiddleware\ApiBundle\Authorization\Filter\InstitutionAuthorizationRepositoryFilter;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\Identity;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Query\IdentityQuery;

class IdentityRepository extends EntityRepository
{
    /**
     * @var InstitutionAuthorizationRepositoryFilter
     */
    private $authorizationRepositoryFilter;

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

    /**
     * @param string $id
     * @return Identity|null
     */
    public function find($id)
    {
        /** @var Identity|null $identity */
        $identity = parent::find($id);

        return $identity;
    }

    /**
     * @param Identity $identity
     */
    public function save(Identity $identity)
    {
        $entityManager = $this->getEntityManager();
        $entityManager->persist($identity);
        $entityManager->flush();
    }

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

        // If no institution context is provided, we are not able to query with authorization context
        if ($query->authorizationContext) {
            // Modify query to filter on authorization
            $this->authorizationRepositoryFilter->filter($queryBuilder, $query->authorizationContext, 'i.id', 'i.institution', 'iac');
        }

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

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

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

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

        return $queryBuilder->getQuery();
    }

    /**
     * @param string[] $nameIds
     * @return Identity[] Indexed by NameID.
     */
    public function findByNameIdsIndexed(array $nameIds)
    {
        return $this->getEntityManager()->createQueryBuilder()
            ->select('i')
            ->from('Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\Identity', 'i', 'i.nameId')
            ->where('i.nameId IN (:nameIds)')
            ->setParameter('nameIds', $nameIds)
            ->getQuery()
            ->getResult();
    }

    /**
     * @param NameId      $nameId
     * @param Institution $institution
     *
     * @return bool
     */
    public function hasIdentityWithNameIdAndInstitution(NameId $nameId, Institution $institution)
    {
        $identityCount = $this->createQueryBuilder('i')
            ->select('COUNT(i.id)')
            ->where('i.nameId = :nameId')
            ->andWhere('i.institution = :institution')
            ->setParameter('nameId', $nameId->getNameId())
            ->setParameter('institution', $institution->getInstitution())
            ->getQuery()
            ->getSingleScalarResult();

        return $identityCount > 0;
    }

    /**
     * @param NameId      $nameId
     * @param Institution $institution
     * @return Identity
     */
    public function findOneByNameIdAndInstitution(NameId $nameId, Institution $institution)
    {
        return $this->createQueryBuilder('i')
                ->where('i.nameId = :nameId')
                ->setParameter('nameId', $nameId->getNameId())
                ->andWhere('i.institution = :institution')
                ->setParameter('institution', $institution->getInstitution())
                ->getQuery()
                ->getSingleResult();
    }

    public function removeByIdentityId(IdentityId $identityId)
    {
        $this->getEntityManager()->createQueryBuilder()
            ->delete($this->_entityName, 'i')
            ->where('i.id = :identityId')
            ->setParameter('identityId', $identityId->getIdentityId())
            ->getQuery()
            ->execute();
    }

    /**
     * @param Institution $institution
     * @return ArrayCollection|Identity[]

     */
    public function findByInstitution(Institution $institution)
    {
        return $this->createQueryBuilder('i')
            ->where('i.institution = :institution')
            ->setParameter('institution', $institution->getInstitution())
            ->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 Surfnet\Stepup\Identity\Value\IdentityId;
26			use Surfnet\Stepup\Identity\Value\Institution;
27			use Surfnet\Stepup\Identity\Value\NameId;
28			use Surfnet\StepupMiddleware\ApiBundle\Authorization\Filter\InstitutionAuthorizationRepositoryFilter;
29			use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\Identity;
30			use Surfnet\StepupMiddleware\ApiBundle\Identity\Query\IdentityQuery;
31
32			class IdentityRepository extends EntityRepository
33			{
34			/**
35			* @var InstitutionAuthorizationRepositoryFilter
36			*/
37			private $authorizationRepositoryFilter;
38
39			public function __construct(
40			EntityManager $em,
41			Mapping\ClassMetadata $class,
42			InstitutionAuthorizationRepositoryFilter $authorizationRepositoryFilter
43			) {
44			parent::__construct($em, $class);
45			$this->authorizationRepositoryFilter = $authorizationRepositoryFilter;
46			}
47
48			/**
49			* @param string $id
50			* @return Identity\|null
51			*/
52			public function find($id)
53			{
54			/** @var Identity\|null $identity */
55			$identity = parent::find($id);
56
57			return $identity;
58			}
59
60			/**
61			* @param Identity $identity
62			*/
63			public function save(Identity $identity)
64			{
65			$entityManager = $this->getEntityManager();
66			$entityManager->persist($identity);
67			$entityManager->flush();
68			}
69
70			/**
71			* @param IdentityQuery $query
72			* @return \Doctrine\ORM\Query
73			*/
74			public function createSearchQuery(
75			IdentityQuery $query
76			) {
77			$queryBuilder = $this->createQueryBuilder('i');
78
79			// If no institution context is provided, we are not able to query with authorization context
80			if ($query->authorizationContext) {
81			// Modify query to filter on authorization
82			$this->authorizationRepositoryFilter->filter($queryBuilder, $query->authorizationContext, 'i.id', 'i.institution', 'iac');
83			}
84
85			if ($query->institution) {
86			$queryBuilder
87			->andWhere('i.institution = :institution')
88			->setParameter('institution', $query->institution);
89			}
90
91			if ($query->nameId) {
92			$queryBuilder
93			->andWhere('i.nameId = :nameId')
94			->setParameter('nameId', $query->nameId);
95			}
96
97			if ($query->email) {
98			$queryBuilder
99			->andWhere('MATCH_AGAINST(i.email, :email) > 0')
100			->setParameter('email', $query->email);
101			}
102
103			if ($query->commonName) {
104			$queryBuilder
105			->andWhere('MATCH_AGAINST(i.commonName, :commonName) > 0')
106			->setParameter('commonName', $query->commonName);
107			}
108
109			return $queryBuilder->getQuery();
110			}
111
112			/**
113			* @param string[] $nameIds
114			* @return Identity[] Indexed by NameID.
115			*/
116			public function findByNameIdsIndexed(array $nameIds)
117			{
118			return $this->getEntityManager()->createQueryBuilder()
119			->select('i')
120			->from('Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\Identity', 'i', 'i.nameId')
121			->where('i.nameId IN (:nameIds)')
122			->setParameter('nameIds', $nameIds)
123			->getQuery()
124			->getResult();
125			}
126
127			/**
128			* @param NameId $nameId
129			* @param Institution $institution
130			*
131			* @return bool
132			*/
133			public function hasIdentityWithNameIdAndInstitution(NameId $nameId, Institution $institution)
134			{
135			$identityCount = $this->createQueryBuilder('i')
136			->select('COUNT(i.id)')
137			->where('i.nameId = :nameId')
138			->andWhere('i.institution = :institution')
139			->setParameter('nameId', $nameId->getNameId())
140			->setParameter('institution', $institution->getInstitution())
141			->getQuery()
142			->getSingleScalarResult();
143
144			return $identityCount > 0;
145			}
146
147			/**
148			* @param NameId $nameId
149			* @param Institution $institution
150			* @return Identity
151			*/
152			public function findOneByNameIdAndInstitution(NameId $nameId, Institution $institution)
153			{
154			return $this->createQueryBuilder('i')
155			->where('i.nameId = :nameId')
156			->setParameter('nameId', $nameId->getNameId())
157			->andWhere('i.institution = :institution')
158			->setParameter('institution', $institution->getInstitution())
159			->getQuery()
160			->getSingleResult();
161			}
162
163			public function removeByIdentityId(IdentityId $identityId)
164			{
165			$this->getEntityManager()->createQueryBuilder()
166			->delete($this->_entityName, 'i')
167			->where('i.id = :identityId')
168			->setParameter('identityId', $identityId->getIdentityId())
169			->getQuery()
170			->execute();
171			}
172
173			/**
174			* @param Institution $institution
175			* @return ArrayCollection\|Identity[]
			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...
176			*/
177			public function findByInstitution(Institution $institution)
178			{
179			return $this->createQueryBuilder('i')
180			->where('i.institution = :institution')
181			->setParameter('institution', $institution->getInstitution())
182			->getQuery()
183			->getResult();
184			}
185			}
186

OpenConext / Stepup-Middleware

Pull Request — develop (#256)

IdentityRepository::find() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like