ConfigurationHelper::getJWTCreatorConfiguration() - Code Metrics - Inspection of "Documentation" - Spomky-Labs/jose-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#24)

by Florent

created 2016-09-28 11:21 UTC

ConfigurationHelper::getJWTCreatorConfiguration() A

↳ Parent: ConfigurationHelper

Complexity

Conditions	1
Paths	1

Size

Total Lines	19
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.4285
c	0
b	0
f	0
nc	1
cc	1
eloc	12
nop	4

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2016 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace SpomkyLabs\JoseBundle\Helper;

use Assert\Assertion;
use Symfony\Component\DependencyInjection\ContainerBuilder;

/**
 * This helper will help you to create services configuration.
 */
final class ConfigurationHelper
{
    const BUNDLE_ALIAS = 'jose';
    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string[]                                                $header_checkers
     * @param string[]                                                $claim_checkers
     * @param bool                                                    $is_public
     */
    public static function addChecker(ContainerBuilder $container, $name, array $header_checkers, array $claim_checkers, $is_public = true)
    {
        $config = self::getCheckerConfiguration($name, $header_checkers, $claim_checkers, $is_public);
            self::updateJoseConfiguration($container, $config, 'checkers');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string[]                                                $signature_algorithms
     * @param bool                                                    $create_verifier
     * @param bool                                                    $is_public
     */
    public static function addSigner(ContainerBuilder $container, $name, array $signature_algorithms, $create_verifier = false, $is_public = true)
    {
        $config = self::getSignerConfiguration($name, $signature_algorithms, $create_verifier, $is_public);
        self::updateJoseConfiguration($container, $config, 'signers');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string[]                                                $signature_algorithms
     * @param bool                                                    $is_public
     */
    public static function addVerifier(ContainerBuilder $container, $name, array $signature_algorithms, $is_public = true)
    {
        $config = self::getVerifierConfiguration($name, $signature_algorithms, $is_public);
        self::updateJoseConfiguration($container, $config, 'verifiers');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string[]                                                $key_encryption_algorithms
     * @param string[]                                                $content_encryption_algorithms
     * @param string[]                                                $compression_methods
     * @param bool                                                    $create_decrypter
     * @param bool                                                    $is_public
     */
    public static function addEncrypter(ContainerBuilder $container, $name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $create_decrypter = false, $is_public = true)
    {
        $config = self::getEncrypterConfiguration($name, $key_encryption_algorithms, $content_encryption_algorithms, $compression_methods, $create_decrypter, $is_public);
        self::updateJoseConfiguration($container, $config, 'encrypters');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string[]                                                $key_encryption_algorithms
     * @param string[]                                                $content_encryption_algorithms
     * @param string[]                                                $compression_methods
     * @param bool                                                    $is_public
     */
    public static function addDecrypter(ContainerBuilder $container, $name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $is_public = true)
    {
        $config = self::getDecrypterConfiguration($name, $key_encryption_algorithms, $content_encryption_algorithms, $compression_methods, $is_public);
        self::updateJoseConfiguration($container, $config, 'decrypters');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string                                                  $signer
     * @param string|null                                             $encrypter
     * @param bool                                                    $is_public
     */
    public static function addJWTCreator(ContainerBuilder $container, $name, $signer, $encrypter = null, $is_public = true)
    {
        $config = self::getJWTCreatorConfiguration($name, $signer, $encrypter, $is_public);
        self::updateJoseConfiguration($container, $config, 'jwt_creators');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string                                                  $verifier
     * @param string                                                  $checker
     * @param string|null                                             $decrypter
     * @param bool                                                    $is_public
     */
    public static function addJWTLoader(ContainerBuilder $container, $name, $verifier, $checker, $decrypter = null, $is_public = true)
    {
        $config = self::getJWTLoaderConfiguration($name, $verifier, $checker, $decrypter, $is_public);
        self::updateJoseConfiguration($container, $config, 'jwt_loaders');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param int                                                     $nb_keys
     * @param array                                                   $key_configuration
     * @param bool                                                    $is_rotatable
     * @param bool                                                    $is_public
     */
    public static function addRandomJWKSet(ContainerBuilder $container, $name, $nb_keys, array $key_configuration, $is_rotatable = false, $is_public = true)
    {
        $config = self::getRandomJWKSetConfiguration($name, $nb_keys, $key_configuration, $is_rotatable, $is_public);
        self::updateJoseConfiguration($container, $config, 'key_sets');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string                                                  $jwkset
     * @param bool                                                    $is_public
     */
    public static function addPublicJWKSet(ContainerBuilder $container, $name, $jwkset, $is_public = true)
    {
        $config = self::getPublicJWKSetConfiguration($name, $jwkset, $is_public);
        self::updateJoseConfiguration($container, $config, 'key_sets');
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string                                                  $name
     * @param string[]                                                $jwksets
     * @param bool                                                    $is_public
     */
    public static function addJWKSets(ContainerBuilder $container, $name, array $jwksets, $is_public = true)
    {
        $config = self::getJWKSetsConfiguration($name, $jwksets, $is_public);
        self::updateJoseConfiguration($container, $config, 'key_sets');
    }

    /**
     * @param string   $name
     * @param string[] $header_checkers
     * @param string[] $claim_checkers
     * @param bool     $is_public
     *
     * @return array
     */
    public static function getCheckerConfiguration($name, array $header_checkers, array $claim_checkers, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::allString($header_checkers);
        Assertion::allString($claim_checkers);

        return [
            self::BUNDLE_ALIAS => [
                'checkers' => [
                    $name => [
                        'is_public' => $is_public,
                        'claims'    => $claim_checkers,
                        'headers'   => $header_checkers,
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string   $name
     * @param string[] $signature_algorithms
     * @param bool     $create_verifier
     * @param bool     $is_public
     *
     * @return array
     */
    public static function getSignerConfiguration($name, array $signature_algorithms, $create_verifier = false, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::allString($signature_algorithms);
        Assertion::notEmpty($signature_algorithms);
        Assertion::boolean($create_verifier);

        return [
            self::BUNDLE_ALIAS => [
                'signers' => [
                    $name => [
                        'is_public'       => $is_public,
                        'algorithms'      => $signature_algorithms,
                        'create_verifier' => $create_verifier,
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string   $name
     * @param string[] $signature_algorithms
     * @param bool     $is_public
     *
     * @return array
     */
    public static function getVerifierConfiguration($name, array $signature_algorithms, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::allString($signature_algorithms);
        Assertion::notEmpty($signature_algorithms);

        return [
            self::BUNDLE_ALIAS => [
                'verifiers' => [
                    $name => [
                        'is_public'  => $is_public,
                        'algorithms' => $signature_algorithms,
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string   $name
     * @param string[] $key_encryption_algorithms
     * @param string[] $content_encryption_algorithms
     * @param string[] $compression_methods
     * @param bool     $create_decrypter
     * @param bool     $is_public
     *
     * @return array
     */
    public static function getEncrypterConfiguration($name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $create_decrypter = false, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::allString($key_encryption_algorithms);
        Assertion::notEmpty($key_encryption_algorithms);
        Assertion::allString($content_encryption_algorithms);
        Assertion::notEmpty($content_encryption_algorithms);
        Assertion::boolean($create_decrypter);

        return [
            self::BUNDLE_ALIAS => [
                'encrypters' => [
                    $name => [
                        'is_public'                     => $is_public,
                        'key_encryption_algorithms'     => $key_encryption_algorithms,
                        'content_encryption_algorithms' => $content_encryption_algorithms,
                        'compression_methods'           => $compression_methods,
                        'create_decrypter'              => $create_decrypter,
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string   $name
     * @param string[] $key_encryption_algorithms
     * @param string[] $content_encryption_algorithms
     * @param string[] $compression_methods
     * @param bool     $is_public
     *
     * @return array
     */
    public static function getDecrypterConfiguration($name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::allString($key_encryption_algorithms);
        Assertion::notEmpty($key_encryption_algorithms);
        Assertion::allString($content_encryption_algorithms);
        Assertion::notEmpty($content_encryption_algorithms);

        return [
            self::BUNDLE_ALIAS => [
                'decrypters' => [
                    $name => [
                        'is_public'                     => $is_public,
                        'key_encryption_algorithms'     => $key_encryption_algorithms,
                        'content_encryption_algorithms' => $content_encryption_algorithms,
                        'compression_methods'           => $compression_methods,
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string      $name
     * @param string      $signer
     * @param string|null $encrypter
     * @param bool        $is_public
     *
     * @return array
     */
    public static function getJWTCreatorConfiguration($name, $signer, $encrypter = null, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::string($signer);
        Assertion::notEmpty($signer);
        Assertion::nullOrString($encrypter);

        return [
            self::BUNDLE_ALIAS => [
                'jwt_creators' => [
                    $name => [
                        'is_public' => $is_public,
                        'signer'    => $signer,
                        'encrypter' => $encrypter,
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string      $name
     * @param string      $verifier
     * @param string      $checker
     * @param string|null $decrypter
     * @param bool        $is_public
     *
     * @return array
     */
    public static function getJWTLoaderConfiguration($name, $verifier, $checker, $decrypter = null, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::string($verifier);
        Assertion::notEmpty($verifier);
        Assertion::string($checker);
        Assertion::notEmpty($checker);
        Assertion::nullOrString($decrypter);

        return [
            self::BUNDLE_ALIAS => [
                'jwt_loaders' => [
                    $name => [
                        'is_public' => $is_public,
                        'verifier'  => $verifier,
                        'checker'   => $checker,
                        'decrypter' => $decrypter,
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string $name
     * @param int    $nb_keys
     * @param array  $key_configuration
     * @param bool   $is_rotatable
     * @param bool   $is_public
     *
     * @return array
     */
    public static function getRandomJWKSetConfiguration($name, $nb_keys, array $key_configuration, $is_rotatable = false, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::integer($nb_keys);
        Assertion::greaterThan($nb_keys, 0);
        Assertion::boolean($is_rotatable);

        return [
            self::BUNDLE_ALIAS => [
                'key_sets' => [
                    $name => [
                        'auto' => [
                            'is_rotatable'      => $is_rotatable,
                            'is_public'         => $is_public,
                            'nb_keys'           => $nb_keys,
                            'key_configuration' => $key_configuration,
                        ],
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string $name
     * @param string $jwkset
     * @param bool   $is_public
     *
     * @return array
     */
    public static function getPublicJWKSetConfiguration($name, $jwkset, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::string($jwkset);
        Assertion::notEmpty($jwkset);

        return [
            self::BUNDLE_ALIAS => [
                'key_sets' => [
                    $name => [
                        'public_jwkset' => [
                            'is_public' => $is_public,
                            'id'        => $jwkset,
                        ],
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string   $name
     * @param string[] $jwksets
     * @param bool     $is_public
     *
     * @return array
     */
    public static function getJWKSetsConfiguration($name, array $jwksets, $is_public = true)
    {
        self::checkParameters($name, $is_public);
        Assertion::isArray($jwksets);
        Assertion::allString($jwksets);
        Assertion::allNotEmpty($jwksets);

        return [
            self::BUNDLE_ALIAS => [
                'key_sets' => [
                    $name => [
                        'jwksets' => [
                            'is_public' => $is_public,
                            'id'        => $jwksets,
                        ],
                    ],
                ],
            ],
        ];
    }

    /**
     * @param string $name
     * @param bool   $is_public
     */
    private static function checkParameters($name, $is_public)
    {
        Assertion::string($name);
        Assertion::notEmpty($name);
        Assertion::boolean($is_public);
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @return array
     */
    private static function getJoseConfiguration(ContainerBuilder $container)
    {
        return current($container->getExtensionConfig(self::BUNDLE_ALIAS));
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param array                                                   $config
     * @param string                                                  $element
     */
    private static function updateJoseConfiguration(ContainerBuilder $container, array $config, $element)
    {
        self::checkJoseBundleEnabled($container);
        $jose_config = self::getJoseConfiguration($container);
        $jose_config[$element] = array_merge(
            $jose_config[$element],
            $config[self::BUNDLE_ALIAS][$element]
        );
        $container->prependExtensionConfig(self::BUNDLE_ALIAS, $config);
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @throws \InvalidArgumentException
     */
    private static function checkJoseBundleEnabled(ContainerBuilder $container)
    {
        $bundles = $container->getParameter('kernel.bundles');
        Assertion::keyExists($bundles, 'SpomkyLabsJoseBundle', 'The "Spomky-Labs/JoseBundle" must be enabled.');

    }
}


1			<?php
2
3			/*
4			* The MIT License (MIT)
5			*
6			* Copyright (c) 2014-2016 Spomky-Labs
7			*
8			* This software may be modified and distributed under the terms
9			* of the MIT license. See the LICENSE file for details.
10			*/
11
12			namespace SpomkyLabs\JoseBundle\Helper;
13
14			use Assert\Assertion;
15			use Symfony\Component\DependencyInjection\ContainerBuilder;
16
17			/**
18			* This helper will help you to create services configuration.
19			*/
20			final class ConfigurationHelper
21			{
22			const BUNDLE_ALIAS = 'jose';
23			/**
24			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
25			* @param string $name
26			* @param string[] $header_checkers
27			* @param string[] $claim_checkers
28			* @param bool $is_public
29			*/
30			public static function addChecker(ContainerBuilder $container, $name, array $header_checkers, array $claim_checkers, $is_public = true)
31			{
32			$config = self::getCheckerConfiguration($name, $header_checkers, $claim_checkers, $is_public);
33			self::updateJoseConfiguration($container, $config, 'checkers');
34			}
35
36			/**
37			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
38			* @param string $name
39			* @param string[] $signature_algorithms
40			* @param bool $create_verifier
41			* @param bool $is_public
42			*/
43			public static function addSigner(ContainerBuilder $container, $name, array $signature_algorithms, $create_verifier = false, $is_public = true)
44			{
45			$config = self::getSignerConfiguration($name, $signature_algorithms, $create_verifier, $is_public);
46			self::updateJoseConfiguration($container, $config, 'signers');
47			}
48
49			/**
50			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
51			* @param string $name
52			* @param string[] $signature_algorithms
53			* @param bool $is_public
54			*/
55			public static function addVerifier(ContainerBuilder $container, $name, array $signature_algorithms, $is_public = true)
56			{
57			$config = self::getVerifierConfiguration($name, $signature_algorithms, $is_public);
58			self::updateJoseConfiguration($container, $config, 'verifiers');
59			}
60
61			/**
62			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
63			* @param string $name
64			* @param string[] $key_encryption_algorithms
65			* @param string[] $content_encryption_algorithms
66			* @param string[] $compression_methods
67			* @param bool $create_decrypter
68			* @param bool $is_public
69			*/
70			public static function addEncrypter(ContainerBuilder $container, $name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $create_decrypter = false, $is_public = true)
71			{
72			$config = self::getEncrypterConfiguration($name, $key_encryption_algorithms, $content_encryption_algorithms, $compression_methods, $create_decrypter, $is_public);
73			self::updateJoseConfiguration($container, $config, 'encrypters');
74			}
75
76			/**
77			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
78			* @param string $name
79			* @param string[] $key_encryption_algorithms
80			* @param string[] $content_encryption_algorithms
81			* @param string[] $compression_methods
82			* @param bool $is_public
83			*/
84			public static function addDecrypter(ContainerBuilder $container, $name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $is_public = true)
85			{
86			$config = self::getDecrypterConfiguration($name, $key_encryption_algorithms, $content_encryption_algorithms, $compression_methods, $is_public);
87			self::updateJoseConfiguration($container, $config, 'decrypters');
88			}
89
90			/**
91			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
92			* @param string $name
93			* @param string $signer
94			* @param string\|null $encrypter
95			* @param bool $is_public
96			*/
97			public static function addJWTCreator(ContainerBuilder $container, $name, $signer, $encrypter = null, $is_public = true)
98			{
99			$config = self::getJWTCreatorConfiguration($name, $signer, $encrypter, $is_public);
100			self::updateJoseConfiguration($container, $config, 'jwt_creators');
101			}
102
103			/**
104			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
105			* @param string $name
106			* @param string $verifier
107			* @param string $checker
108			* @param string\|null $decrypter
109			* @param bool $is_public
110			*/
111			public static function addJWTLoader(ContainerBuilder $container, $name, $verifier, $checker, $decrypter = null, $is_public = true)
112			{
113			$config = self::getJWTLoaderConfiguration($name, $verifier, $checker, $decrypter, $is_public);
114			self::updateJoseConfiguration($container, $config, 'jwt_loaders');
115			}
116
117			/**
118			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
119			* @param string $name
120			* @param int $nb_keys
121			* @param array $key_configuration
122			* @param bool $is_rotatable
123			* @param bool $is_public
124			*/
125			public static function addRandomJWKSet(ContainerBuilder $container, $name, $nb_keys, array $key_configuration, $is_rotatable = false, $is_public = true)
126			{
127			$config = self::getRandomJWKSetConfiguration($name, $nb_keys, $key_configuration, $is_rotatable, $is_public);
128			self::updateJoseConfiguration($container, $config, 'key_sets');
129			}
130
131			/**
132			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
133			* @param string $name
134			* @param string $jwkset
135			* @param bool $is_public
136			*/
137			public static function addPublicJWKSet(ContainerBuilder $container, $name, $jwkset, $is_public = true)
138			{
139			$config = self::getPublicJWKSetConfiguration($name, $jwkset, $is_public);
140			self::updateJoseConfiguration($container, $config, 'key_sets');
141			}
142
143			/**
144			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
145			* @param string $name
146			* @param string[] $jwksets
147			* @param bool $is_public
148			*/
149			public static function addJWKSets(ContainerBuilder $container, $name, array $jwksets, $is_public = true)
150			{
151			$config = self::getJWKSetsConfiguration($name, $jwksets, $is_public);
152			self::updateJoseConfiguration($container, $config, 'key_sets');
153			}
154
155			/**
156			* @param string $name
157			* @param string[] $header_checkers
158			* @param string[] $claim_checkers
159			* @param bool $is_public
160			*
161			* @return array
162			*/
163			public static function getCheckerConfiguration($name, array $header_checkers, array $claim_checkers, $is_public = true)
164			{
165			self::checkParameters($name, $is_public);
166			Assertion::allString($header_checkers);
167			Assertion::allString($claim_checkers);
168
169			return [
170			self::BUNDLE_ALIAS => [
171			'checkers' => [
172			$name => [
173			'is_public' => $is_public,
174			'claims' => $claim_checkers,
175			'headers' => $header_checkers,
176			],
177			],
178			],
179			];
180			}
181
182			/**
183			* @param string $name
184			* @param string[] $signature_algorithms
185			* @param bool $create_verifier
186			* @param bool $is_public
187			*
188			* @return array
189			*/
190			public static function getSignerConfiguration($name, array $signature_algorithms, $create_verifier = false, $is_public = true)
191			{
192			self::checkParameters($name, $is_public);
193			Assertion::allString($signature_algorithms);
194			Assertion::notEmpty($signature_algorithms);
195			Assertion::boolean($create_verifier);
196
197			return [
198			self::BUNDLE_ALIAS => [
199			'signers' => [
200			$name => [
201			'is_public' => $is_public,
202			'algorithms' => $signature_algorithms,
203			'create_verifier' => $create_verifier,
204			],
205			],
206			],
207			];
208			}
209
210			/**
211			* @param string $name
212			* @param string[] $signature_algorithms
213			* @param bool $is_public
214			*
215			* @return array
216			*/
217			public static function getVerifierConfiguration($name, array $signature_algorithms, $is_public = true)
218			{
219			self::checkParameters($name, $is_public);
220			Assertion::allString($signature_algorithms);
221			Assertion::notEmpty($signature_algorithms);
222
223			return [
224			self::BUNDLE_ALIAS => [
225			'verifiers' => [
226			$name => [
227			'is_public' => $is_public,
228			'algorithms' => $signature_algorithms,
229			],
230			],
231			],
232			];
233			}
234
235			/**
236			* @param string $name
237			* @param string[] $key_encryption_algorithms
238			* @param string[] $content_encryption_algorithms
239			* @param string[] $compression_methods
240			* @param bool $create_decrypter
241			* @param bool $is_public
242			*
243			* @return array
244			*/
245			public static function getEncrypterConfiguration($name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $create_decrypter = false, $is_public = true)
246			{
247			self::checkParameters($name, $is_public);
248			Assertion::allString($key_encryption_algorithms);
249			Assertion::notEmpty($key_encryption_algorithms);
250			Assertion::allString($content_encryption_algorithms);
251			Assertion::notEmpty($content_encryption_algorithms);
252			Assertion::boolean($create_decrypter);
253
254			return [
255			self::BUNDLE_ALIAS => [
256			'encrypters' => [
257			$name => [
258			'is_public' => $is_public,
259			'key_encryption_algorithms' => $key_encryption_algorithms,
260			'content_encryption_algorithms' => $content_encryption_algorithms,
261			'compression_methods' => $compression_methods,
262			'create_decrypter' => $create_decrypter,
263			],
264			],
265			],
266			];
267			}
268
269			/**
270			* @param string $name
271			* @param string[] $key_encryption_algorithms
272			* @param string[] $content_encryption_algorithms
273			* @param string[] $compression_methods
274			* @param bool $is_public
275			*
276			* @return array
277			*/
278			public static function getDecrypterConfiguration($name, array $key_encryption_algorithms, array $content_encryption_algorithms, array $compression_methods = ['DEF'], $is_public = true)
279			{
280			self::checkParameters($name, $is_public);
281			Assertion::allString($key_encryption_algorithms);
282			Assertion::notEmpty($key_encryption_algorithms);
283			Assertion::allString($content_encryption_algorithms);
284			Assertion::notEmpty($content_encryption_algorithms);
285
286			return [
287			self::BUNDLE_ALIAS => [
288			'decrypters' => [
289			$name => [
290			'is_public' => $is_public,
291			'key_encryption_algorithms' => $key_encryption_algorithms,
292			'content_encryption_algorithms' => $content_encryption_algorithms,
293			'compression_methods' => $compression_methods,
294			],
295			],
296			],
297			];
298			}
299
300			/**
301			* @param string $name
302			* @param string $signer
303			* @param string\|null $encrypter
304			* @param bool $is_public
305			*
306			* @return array
307			*/
308			public static function getJWTCreatorConfiguration($name, $signer, $encrypter = null, $is_public = true)
309			{
310			self::checkParameters($name, $is_public);
311			Assertion::string($signer);
312			Assertion::notEmpty($signer);
313			Assertion::nullOrString($encrypter);
314
315			return [
316			self::BUNDLE_ALIAS => [
317			'jwt_creators' => [
318			$name => [
319			'is_public' => $is_public,
320			'signer' => $signer,
321			'encrypter' => $encrypter,
322			],
323			],
324			],
325			];
326			}
327
328			/**
329			* @param string $name
330			* @param string $verifier
331			* @param string $checker
332			* @param string\|null $decrypter
333			* @param bool $is_public
334			*
335			* @return array
336			*/
337			public static function getJWTLoaderConfiguration($name, $verifier, $checker, $decrypter = null, $is_public = true)
338			{
339			self::checkParameters($name, $is_public);
340			Assertion::string($verifier);
341			Assertion::notEmpty($verifier);
342			Assertion::string($checker);
343			Assertion::notEmpty($checker);
344			Assertion::nullOrString($decrypter);
345
346			return [
347			self::BUNDLE_ALIAS => [
348			'jwt_loaders' => [
349			$name => [
350			'is_public' => $is_public,
351			'verifier' => $verifier,
352			'checker' => $checker,
353			'decrypter' => $decrypter,
354			],
355			],
356			],
357			];
358			}
359
360			/**
361			* @param string $name
362			* @param int $nb_keys
363			* @param array $key_configuration
364			* @param bool $is_rotatable
365			* @param bool $is_public
366			*
367			* @return array
368			*/
369			public static function getRandomJWKSetConfiguration($name, $nb_keys, array $key_configuration, $is_rotatable = false, $is_public = true)
370			{
371			self::checkParameters($name, $is_public);
372			Assertion::integer($nb_keys);
373			Assertion::greaterThan($nb_keys, 0);
374			Assertion::boolean($is_rotatable);
375
376			return [
377			self::BUNDLE_ALIAS => [
378			'key_sets' => [
379			$name => [
380			'auto' => [
381			'is_rotatable' => $is_rotatable,
382			'is_public' => $is_public,
383			'nb_keys' => $nb_keys,
384			'key_configuration' => $key_configuration,
385			],
386			],
387			],
388			],
389			];
390			}
391
392			/**
393			* @param string $name
394			* @param string $jwkset
395			* @param bool $is_public
396			*
397			* @return array
398			*/
399			public static function getPublicJWKSetConfiguration($name, $jwkset, $is_public = true)
400			{
401			self::checkParameters($name, $is_public);
402			Assertion::string($jwkset);
403			Assertion::notEmpty($jwkset);
404
405			return [
406			self::BUNDLE_ALIAS => [
407			'key_sets' => [
408			$name => [
409			'public_jwkset' => [
410			'is_public' => $is_public,
411			'id' => $jwkset,
412			],
413			],
414			],
415			],
416			];
417			}
418
419			/**
420			* @param string $name
421			* @param string[] $jwksets
422			* @param bool $is_public
423			*
424			* @return array
425			*/
426			public static function getJWKSetsConfiguration($name, array $jwksets, $is_public = true)
427			{
428			self::checkParameters($name, $is_public);
429			Assertion::isArray($jwksets);
430			Assertion::allString($jwksets);
431			Assertion::allNotEmpty($jwksets);
432
433			return [
434			self::BUNDLE_ALIAS => [
435			'key_sets' => [
436			$name => [
437			'jwksets' => [
438			'is_public' => $is_public,
439			'id' => $jwksets,
440			],
441			],
442			],
443			],
444			];
445			}
446
447			/**
448			* @param string $name
449			* @param bool $is_public
450			*/
451			private static function checkParameters($name, $is_public)
452			{
453			Assertion::string($name);
454			Assertion::notEmpty($name);
455			Assertion::boolean($is_public);
456			}
457
458			/**
459			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
460			*
461			* @return array
462			*/
463			private static function getJoseConfiguration(ContainerBuilder $container)
464			{
465			return current($container->getExtensionConfig(self::BUNDLE_ALIAS));
466			}
467
468			/**
469			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
470			* @param array $config
471			* @param string $element
472			*/
473			private static function updateJoseConfiguration(ContainerBuilder $container, array $config, $element)
474			{
475			self::checkJoseBundleEnabled($container);
476			$jose_config = self::getJoseConfiguration($container);
477			$jose_config[$element] = array_merge(
478			$jose_config[$element],
479			$config[self::BUNDLE_ALIAS][$element]
480			);
481			$container->prependExtensionConfig(self::BUNDLE_ALIAS, $config);
482			}
483
484			/**
485			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
486			*
487			* @throws \InvalidArgumentException
488			*/
489			private static function checkJoseBundleEnabled(ContainerBuilder $container)
490			{
491			$bundles = $container->getParameter('kernel.bundles');
492			Assertion::keyExists($bundles, 'SpomkyLabsJoseBundle', 'The "Spomky-Labs/JoseBundle" must be enabled.');
493
494			}
495			}
496

Spomky-Labs / jose-bundle

Pull Request — master (#24)

ConfigurationHelper::getJWTCreatorConfiguration() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like