ReconfigureInstitutionRequestValidator::determineNonExistentInstitutions() - Code Metrics - Inspection of "Update the institution configuration aggregate" - OpenConext/Stepup-Middleware - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — develop (#232)

by Michiel

created 2018-09-24 08:57 UTC

determineNonExistentInstitutions() A

↳ Parent: ReconfigureInstitutionRequestValidator

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	18
rs	9.6666
c	0
b	0
f	0
cc	1
nc	1
nop	2

<?php

/**
 * Copyright 2016 SURFnet B.V.
 *
 * 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\ManagementBundle\Validator;

use Assert\Assertion;
use Assert\InvalidArgumentException as AssertionException;
use InvalidArgumentException as CoreInvalidArgumentException;
use Surfnet\StepupBundle\Service\SecondFactorTypeService;
use Surfnet\StepupMiddleware\ApiBundle\Configuration\Entity\ConfiguredInstitution;
use Surfnet\StepupMiddleware\ApiBundle\Configuration\Service\ConfiguredInstitutionService;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\WhitelistEntry;
use Surfnet\StepupMiddleware\ApiBundle\Identity\Service\WhitelistService;
use Surfnet\StepupMiddleware\ManagementBundle\Exception\InvalidArgumentException;
use Surfnet\StepupMiddleware\ManagementBundle\Validator\Assert as StepupAssert;
use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\ConstraintValidator;

final class ReconfigureInstitutionRequestValidator extends ConstraintValidator
{
    /**
     * @var ConfiguredInstitutionService
     */
    private $configuredInstitutionsService;

    /**
     * @var string[] internal cache, access through getConfiguredInstitutions()
     */
    private $configuredInstitutions;

    /**
     * @var SecondFactorTypeService
     */
    private $secondFactorTypeService;

    /**
     * @var WhitelistService
     */
    private $whitelistService;

    /**
     * @var string[] internal cache, access through getWhitelistedInstitutions()
     */
    private $whitelistedInstitutions;

    public function __construct(
        ConfiguredInstitutionService $configuredInstitutionsService,
        SecondFactorTypeService $secondFactorTypeService,
        WhitelistService $whitelistService
    ) {
        $this->configuredInstitutionsService = $configuredInstitutionsService;
        $this->secondFactorTypeService = $secondFactorTypeService;
        $this->whitelistService = $whitelistService;
    }

    public function validate($value, Constraint $constraint)

    {
        /** @var \Symfony\Component\Validator\Violation\ConstraintViolationBuilder|false $violation */
        $violation = false;

        try {
            $this->validateRoot($value);
        } catch (AssertionException $exception) {
            // method is not in the interface yet, but the old method is deprecated.
            $violation = $this->context->buildViolation($exception->getMessage());
            $violation->atPath($exception->getPropertyPath());
        } catch (CoreInvalidArgumentException $exception) {
            $violation = $this->context->buildViolation($exception->getMessage());
        }

        if ($violation) {
            $violation->addViolation();
        }
    }

    public function validateRoot(array $configuration)
    {
        Assertion::isArray($configuration, 'Invalid body structure, must be an object', '(root)');
        $this->validateInstitutionsExist(array_keys($configuration));

        foreach ($configuration as $institution => $options) {
            $this->validateInstitutionConfigurationOptions($options, $institution);
        }
    }

    /**
     * @param array $institutions
     */
    public function validateInstitutionsExist(array $institutions)
    {
        $configuredInstitutions = $this->getConfiguredInstitutions();

        $nonExistentInstitutions = $this->determineNonExistentInstitutions($institutions, $configuredInstitutions);

        if (!empty($nonExistentInstitutions)) {
            throw new InvalidArgumentException(
                sprintf('Cannot reconfigure non-existent institution(s): %s', implode(', ', $nonExistentInstitutions))
            );
        }
    }

    /**
     * @param array $options
     * @param string $institution
     */
    public function validateInstitutionConfigurationOptions($options, $institution)
    {
        $propertyPath = sprintf('Institution(%s)', $institution);

        Assertion::isArray($options, 'Invalid institution configuration, must be an object', $propertyPath);

        $requiredOptions = [
            'use_ra_locations',
            'show_raa_contact_information',
            'verify_email',
            'number_of_tokens_per_identity',
            'allowed_second_factors',
        ];

        $optionalOptions = [
            'use_ra',
            'use_raa',
            'select_raa',
        ];

        StepupAssert::requiredAndOptionalOptions(
            $options,
            $requiredOptions,
            $optionalOptions,
            sprintf('Expected only options "%s" for "%s"', join(', ', $requiredOptions), $institution),
            $propertyPath
        );

        Assertion::boolean(
            $options['use_ra_locations'],
            sprintf('Option "use_ra_locations" for "%s" must be a boolean value', $institution),
            $propertyPath
        );

        Assertion::boolean(
            $options['show_raa_contact_information'],
            sprintf('Option "show_raa_contact_information" for "%s" must be a boolean value', $institution),
            $propertyPath
        );

        Assertion::boolean(
            $options['verify_email'],
            sprintf('Option "verify_email" for "%s" must be a boolean value', $institution),
            $propertyPath
        );

        Assertion::integer(
            $options['number_of_tokens_per_identity'],
            sprintf('Option "number_of_tokens_per_identity" for "%s" must be an integer value', $institution),
            $propertyPath
        );

        Assertion::min(
            $options['number_of_tokens_per_identity'],
            0,
            sprintf('Option "number_of_tokens_per_identity" for "%s" must be greater than or equal to 0', $institution),
            $propertyPath
        );

        Assertion::isArray(
            $options['allowed_second_factors'],
            sprintf('Option "allowed_second_factors" for "%s" must be an array of strings', $institution),
            $propertyPath
        );
        Assertion::allString(
            $options['allowed_second_factors'],
            sprintf('Option "allowed_second_factors" for "%s" must be an array of strings', $institution),
            $propertyPath
        );
        Assertion::allInArray(
            $options['allowed_second_factors'],
            $this->secondFactorTypeService->getAvailableSecondFactorTypes(),
            'Option "allowed_second_factors" for "%s" must contain valid second factor types',
            $propertyPath
        );

        $this->validateAuthorizationSettings($options, $institution, $propertyPath);
    }

    /**
     * Accessor for configured institutions to be able to use an internal cache
     *
     * @return string[]
     */
    private function getConfiguredInstitutions()
    {
        if (!empty($this->configuredInstitutions)) {
            return $this->configuredInstitutions;
        }

        $this->configuredInstitutions = array_map(
            function (ConfiguredInstitution $configuredInstitution) {
                return $configuredInstitution->institution->getInstitution();
            },
            $this->configuredInstitutionsService->getAll()
        );

        return $this->configuredInstitutions;
    }

    /**
     * Accessor for whitelisted institutions to be able to use an internal cache
     *
     * @return string[]
     */
    private function getWhitelistedInstitutions()
    {
        if (!empty($this->whitelistedInstitutions)) {
            return $this->whitelistedInstitutions;
        }

        $this->whitelistedInstitutions = array_map(
            function (WhitelistEntry $whitelistEntry) {
                return (string)$whitelistEntry->institution;
            },
            $this->whitelistService->getAllEntries()->toArray()
        );

        return $this->whitelistedInstitutions;
    }

    /**
     * @param string[] $institutions
     * @param $configuredInstitutions
     * @return string[]
     */
    public function determineNonExistentInstitutions(array $institutions, $configuredInstitutions)
    {
        $normalizedConfiguredInstitutions = array_map(
            function ($institution) {
                return strtolower($institution);
            },
            $configuredInstitutions
        );

        return array_filter(
            $institutions,
            function ($institution) use ($normalizedConfiguredInstitutions) {
                $normalizedInstitution = strtolower($institution);

                return !in_array($normalizedInstitution, $normalizedConfiguredInstitutions);
            }
        );
    }

    /**
     * Validates if the authorization_settings array is configured correctly
     *
     *  - The optional options should contain whitelisted institutions
     *  - Or be empty
     *
     * @param $authorizationSettings
     * @param $institution
     * @param $propertyPath
     * @throws \Assert\AssertionFailedException
     */
    private function validateAuthorizationSettings($authorizationSettings, $institution, $propertyPath)
    {
        $acceptedOptions = [
            'use_ra',
            'use_raa',
            'select_raa',
        ];

        $whitelistedInstitutions = $this->getWhitelistedInstitutions();

        foreach ($authorizationSettings as $optionName => $setting) {
            if (in_array($optionName, $acceptedOptions)) {

                // 1. Value must be array
                Assertion::isArray(
                    $authorizationSettings[$optionName],
                    sprintf(
                        'Option "%s" for "%s" must be an array of strings. ("%s") was passed.',
                        $optionName,
                        $institution,
                        var_export($setting, true)
                    ),
                    $propertyPath
                );

                // 2. The contents of the array must be empty or string
                Assertion::allString(
                    $authorizationSettings[$optionName],
                    sprintf(
                        'All values of option "%s" should be of type string. ("%s") was passed.',
                        $optionName,
                        $institution,
                        var_export($setting, true)
                    ),
                    $propertyPath
                );

                // 3. The institutions that are used in the configuration, should be known, configured, institutions
                Assertion::allInArray(
                    $authorizationSettings[$optionName],
                    $whitelistedInstitutions,
                    sprintf(
                        'All values of option "%s" should be known institutions. ("%s") was passed.',
                        $optionName,
                        $institution,
                        var_export($setting, true)
                    ),
                    $propertyPath
                );
            }
        }
    }
}


1		<?php
2
3		/**
4		* Copyright 2016 SURFnet B.V.
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\ManagementBundle\Validator;
20
21		use Assert\Assertion;
22		use Assert\InvalidArgumentException as AssertionException;
23		use InvalidArgumentException as CoreInvalidArgumentException;
24		use Surfnet\StepupBundle\Service\SecondFactorTypeService;
25		use Surfnet\StepupMiddleware\ApiBundle\Configuration\Entity\ConfiguredInstitution;
26		use Surfnet\StepupMiddleware\ApiBundle\Configuration\Service\ConfiguredInstitutionService;
27		use Surfnet\StepupMiddleware\ApiBundle\Identity\Entity\WhitelistEntry;
28		use Surfnet\StepupMiddleware\ApiBundle\Identity\Service\WhitelistService;
29		use Surfnet\StepupMiddleware\ManagementBundle\Exception\InvalidArgumentException;
30		use Surfnet\StepupMiddleware\ManagementBundle\Validator\Assert as StepupAssert;
31		use Symfony\Component\Validator\Constraint;
32		use Symfony\Component\Validator\ConstraintValidator;
33
34		final class ReconfigureInstitutionRequestValidator extends ConstraintValidator
35		{
36		/**
37		* @var ConfiguredInstitutionService
38		*/
39		private $configuredInstitutionsService;
40
41		/**
42		* @var string[] internal cache, access through getConfiguredInstitutions()
43		*/
44		private $configuredInstitutions;
45
46		/**
47		* @var SecondFactorTypeService
48		*/
49		private $secondFactorTypeService;
50
51		/**
52		* @var WhitelistService
53		*/
54		private $whitelistService;
55
56		/**
57		* @var string[] internal cache, access through getWhitelistedInstitutions()
58		*/
59		private $whitelistedInstitutions;
60
61		public function __construct(
62		ConfiguredInstitutionService $configuredInstitutionsService,
63		SecondFactorTypeService $secondFactorTypeService,
64		WhitelistService $whitelistService
65		) {
66		$this->configuredInstitutionsService = $configuredInstitutionsService;
67		$this->secondFactorTypeService = $secondFactorTypeService;
68		$this->whitelistService = $whitelistService;
69		}
70
71	View Code Duplication	public function validate($value, Constraint $constraint)
		0 ignored issues – show Duplication introduced 2017-08-01 07:44 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
72		{
73		/** @var \Symfony\Component\Validator\Violation\ConstraintViolationBuilder\|false $violation */
74		$violation = false;
75
76		try {
77		$this->validateRoot($value);
78		} catch (AssertionException $exception) {
79		// method is not in the interface yet, but the old method is deprecated.
80		$violation = $this->context->buildViolation($exception->getMessage());
81		$violation->atPath($exception->getPropertyPath());
82		} catch (CoreInvalidArgumentException $exception) {
83		$violation = $this->context->buildViolation($exception->getMessage());
84		}
85
86		if ($violation) {
87		$violation->addViolation();
88		}
89		}
90
91		public function validateRoot(array $configuration)
92		{
93		Assertion::isArray($configuration, 'Invalid body structure, must be an object', '(root)');
94		$this->validateInstitutionsExist(array_keys($configuration));
95
96		foreach ($configuration as $institution => $options) {
97		$this->validateInstitutionConfigurationOptions($options, $institution);
98		}
99		}
100
101		/**
102		* @param array $institutions
103		*/
104		public function validateInstitutionsExist(array $institutions)
105		{
106		$configuredInstitutions = $this->getConfiguredInstitutions();
107
108		$nonExistentInstitutions = $this->determineNonExistentInstitutions($institutions, $configuredInstitutions);
109
110		if (!empty($nonExistentInstitutions)) {
111		throw new InvalidArgumentException(
112		sprintf('Cannot reconfigure non-existent institution(s): %s', implode(', ', $nonExistentInstitutions))
113		);
114		}
115		}
116
117		/**
118		* @param array $options
119		* @param string $institution
120		*/
121		public function validateInstitutionConfigurationOptions($options, $institution)
122		{
123		$propertyPath = sprintf('Institution(%s)', $institution);
124
125		Assertion::isArray($options, 'Invalid institution configuration, must be an object', $propertyPath);
126
127		$requiredOptions = [
128		'use_ra_locations',
129		'show_raa_contact_information',
130		'verify_email',
131		'number_of_tokens_per_identity',
132		'allowed_second_factors',
133		];
134
135		$optionalOptions = [
136		'use_ra',
137		'use_raa',
138		'select_raa',
139		];
140
141		StepupAssert::requiredAndOptionalOptions(
142		$options,
143		$requiredOptions,
144		$optionalOptions,
145		sprintf('Expected only options "%s" for "%s"', join(', ', $requiredOptions), $institution),
146		$propertyPath
147		);
148
149		Assertion::boolean(
150		$options['use_ra_locations'],
151		sprintf('Option "use_ra_locations" for "%s" must be a boolean value', $institution),
152		$propertyPath
153		);
154
155		Assertion::boolean(
156		$options['show_raa_contact_information'],
157		sprintf('Option "show_raa_contact_information" for "%s" must be a boolean value', $institution),
158		$propertyPath
159		);
160
161		Assertion::boolean(
162		$options['verify_email'],
163		sprintf('Option "verify_email" for "%s" must be a boolean value', $institution),
164		$propertyPath
165		);
166
167		Assertion::integer(
168		$options['number_of_tokens_per_identity'],
169		sprintf('Option "number_of_tokens_per_identity" for "%s" must be an integer value', $institution),
170		$propertyPath
171		);
172
173		Assertion::min(
174		$options['number_of_tokens_per_identity'],
175		0,
176		sprintf('Option "number_of_tokens_per_identity" for "%s" must be greater than or equal to 0', $institution),
177		$propertyPath
178		);
179
180		Assertion::isArray(
181		$options['allowed_second_factors'],
182		sprintf('Option "allowed_second_factors" for "%s" must be an array of strings', $institution),
183		$propertyPath
184		);
185		Assertion::allString(
186		$options['allowed_second_factors'],
187		sprintf('Option "allowed_second_factors" for "%s" must be an array of strings', $institution),
188		$propertyPath
189		);
190		Assertion::allInArray(
191		$options['allowed_second_factors'],
192		$this->secondFactorTypeService->getAvailableSecondFactorTypes(),
193		'Option "allowed_second_factors" for "%s" must contain valid second factor types',
194		$propertyPath
195		);
196
197		$this->validateAuthorizationSettings($options, $institution, $propertyPath);
198		}
199
200		/**
201		* Accessor for configured institutions to be able to use an internal cache
202		*
203		* @return string[]
204		*/
205		private function getConfiguredInstitutions()
206		{
207		if (!empty($this->configuredInstitutions)) {
208		return $this->configuredInstitutions;
209		}
210
211		$this->configuredInstitutions = array_map(
212		function (ConfiguredInstitution $configuredInstitution) {
213		return $configuredInstitution->institution->getInstitution();
214		},
215		$this->configuredInstitutionsService->getAll()
216		);
217
218		return $this->configuredInstitutions;
219		}
220
221		/**
222		* Accessor for whitelisted institutions to be able to use an internal cache
223		*
224		* @return string[]
225		*/
226		private function getWhitelistedInstitutions()
227		{
228		if (!empty($this->whitelistedInstitutions)) {
229		return $this->whitelistedInstitutions;
230		}
231
232		$this->whitelistedInstitutions = array_map(
233		function (WhitelistEntry $whitelistEntry) {
234		return (string)$whitelistEntry->institution;
235		},
236		$this->whitelistService->getAllEntries()->toArray()
237		);
238
239		return $this->whitelistedInstitutions;
240		}
241
242		/**
243		* @param string[] $institutions
244		* @param $configuredInstitutions
245		* @return string[]
246		*/
247		public function determineNonExistentInstitutions(array $institutions, $configuredInstitutions)
248		{
249		$normalizedConfiguredInstitutions = array_map(
250		function ($institution) {
251		return strtolower($institution);
252		},
253		$configuredInstitutions
254		);
255
256		return array_filter(
257		$institutions,
258		function ($institution) use ($normalizedConfiguredInstitutions) {
259		$normalizedInstitution = strtolower($institution);
260
261		return !in_array($normalizedInstitution, $normalizedConfiguredInstitutions);
262		}
263		);
264		}
265
266		/**
267		* Validates if the authorization_settings array is configured correctly
268		*
269		* - The optional options should contain whitelisted institutions
270		* - Or be empty
271		*
272		* @param $authorizationSettings
273		* @param $institution
274		* @param $propertyPath
275		* @throws \Assert\AssertionFailedException
276		*/
277		private function validateAuthorizationSettings($authorizationSettings, $institution, $propertyPath)
278		{
279		$acceptedOptions = [
280		'use_ra',
281		'use_raa',
282		'select_raa',
283		];
284
285		$whitelistedInstitutions = $this->getWhitelistedInstitutions();
286
287		foreach ($authorizationSettings as $optionName => $setting) {
288		if (in_array($optionName, $acceptedOptions)) {
289
290		// 1. Value must be array
291		Assertion::isArray(
292		$authorizationSettings[$optionName],
293		sprintf(
294		'Option "%s" for "%s" must be an array of strings. ("%s") was passed.',
295		$optionName,
296		$institution,
297		var_export($setting, true)
298		),
299		$propertyPath
300		);
301
302		// 2. The contents of the array must be empty or string
303		Assertion::allString(
304		$authorizationSettings[$optionName],
305		sprintf(
306		'All values of option "%s" should be of type string. ("%s") was passed.',
307		$optionName,
308		$institution,
309		var_export($setting, true)
310		),
311		$propertyPath
312		);
313
314		// 3. The institutions that are used in the configuration, should be known, configured, institutions
315		Assertion::allInArray(
316		$authorizationSettings[$optionName],
317		$whitelistedInstitutions,
318		sprintf(
319		'All values of option "%s" should be known institutions. ("%s") was passed.',
320		$optionName,
321		$institution,
322		var_export($setting, true)
323		),
324		$propertyPath
325		);
326		}
327		}
328		}
329		}
330

OpenConext / Stepup-Middleware

Pull Request — develop (#232)

determineNonExistentInstitutions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like