ConfigProvider::getDependenciesConfig() - Code Metrics - SlayerBirden/dataflow-server - Measure and Improve Code Quality continuously with Scrutinizer

ConfigProvider::getDependenciesConfig() A
last analyzed 2018-10-26 15:03 UTC

↳ Parent: ConfigProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	11
ccs	0
cts	2
cp	0
rs	9.9
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	2

<?php
declare(strict_types=1);

namespace SlayerBirden\DataFlowServer\Domain;

use Psr\Log\LoggerInterface;
use SlayerBirden\DataFlowServer\Authentication\Middleware\TokenMiddleware;
use SlayerBirden\DataFlowServer\Doctrine\Persistence\EntityManagerRegistry;
use SlayerBirden\DataFlowServer\Domain\Controller\AddUserAction;
use SlayerBirden\DataFlowServer\Domain\Controller\DeleteUserAction;
use SlayerBirden\DataFlowServer\Domain\Controller\GetUserAction;
use SlayerBirden\DataFlowServer\Domain\Controller\GetUsersAction;
use SlayerBirden\DataFlowServer\Domain\Controller\UpdateUserAction;
use SlayerBirden\DataFlowServer\Domain\Factory\InputFilterMiddlewareFactory;
use SlayerBirden\DataFlowServer\Domain\Factory\UserRepositoryFactory;
use SlayerBirden\DataFlowServer\Domain\Factory\UserResourceMiddlewareFactory;
use SlayerBirden\DataFlowServer\Zend\InputFilter\ProxyFilterManagerFactory;
use Zend\Expressive\Helper\BodyParams\BodyParamsMiddleware;
use Zend\Hydrator\ClassMethods;
use Zend\ServiceManager\AbstractFactory\ConfigAbstractFactory;

class ConfigProvider
{
    public function __invoke(): array
    {
        return [
            ConfigAbstractFactory::class => $this->getAbstractFactoryConfig(),
            'doctrine' => $this->getDoctrineConfig(),
            'dependencies' => $this->getDependenciesConfig(),
            'input_filter_specs' => [
                'UserInputFilter' => $this->getUserInputFilterSpec(),
            ],
            'routes' => $this->getRoutesConfig(),
        ];
    }

    private function getUserInputFilterSpec(): array
    {
        return [
            'first' => [
                'filters' => [
                    [
                        'name' => 'stringtrim',
                    ]
                ],
                'validators' => [
                    [
                        'name' => 'notempty',
                    ],
                    [
                        'name' => 'alpha',
                    ],
                ]
            ],
            'last' => [
                'filters' => [
                    [
                        'name' => 'stringtrim',
                    ]
                ],
                'validators' => [
                    [
                        'name' => 'notempty',
                    ],
                    [
                        'name' => 'alpha',
                    ],
                ]
            ],
            'email' => [
                'filters' => [
                    [
                        'name' => 'stringtrim',
                    ]
                ],
                'validators' => [
                    [
                        'name' => 'notempty',
                    ],
                    [
                        'name' => 'emailAddress',
                    ],
                ],
            ],
        ];
    }

    private function getAbstractFactoryConfig(): array
    {
        return [
            AddUserAction::class => [
                EntityManagerRegistry::class,
                ClassMethods::class,
                LoggerInterface::class,
            ],
            UpdateUserAction::class => [
                EntityManagerRegistry::class,
                ClassMethods::class,
                LoggerInterface::class,
            ],
            GetUserAction::class => [
                ClassMethods::class,
            ],
            GetUsersAction::class => [
                'UserRepository',
                LoggerInterface::class,
                ClassMethods::class,
            ],
            DeleteUserAction::class => [
                EntityManagerRegistry::class,
                LoggerInterface::class,
                ClassMethods::class,
            ],
        ];
    }

    private function getDoctrineConfig(): array
    {
        return [
            'entity_managers' => [
                'default' => [
                    'paths' => [
                        'src/Domain/Entities',
                    ],
                ],
            ],
        ];
    }

    private function getDependenciesConfig(): array
    {
        return [
            'factories' => [
                'UserInputFilter' => ProxyFilterManagerFactory::class,
                'UserResourceMiddleware' => UserResourceMiddlewareFactory::class,
                'UserRepository' => UserRepositoryFactory::class,
                'UserInputFilterMiddleware' => InputFilterMiddlewareFactory::class
            ],
        ];
    }

    public function getRoutesConfig(): array
    {
        return [
            [
                'path' => '/user/{id:\d+}',
                'middleware' => [
                    TokenMiddleware::class,
                    'UserResourceMiddleware',
                    GetUserAction::class,
                ],
                'name' => 'get_user',
                'allowed_methods' => ['GET'],
            ],
            [
                'path' => '/users',
                'middleware' => [
                    TokenMiddleware::class,
                    GetUsersAction::class,
                ],
                'name' => 'get_users',
                'allowed_methods' => ['GET'],
            ],
            [
                'path' => '/user',
                'middleware' => [
                    TokenMiddleware::class,
                    BodyParamsMiddleware::class,
                    'UserInputFilterMiddleware',
                    AddUserAction::class,
                ],
                'name' => 'add_user',
                'allowed_methods' => ['POST'],
            ],
            [
                'path' => '/user/{id:\d+}',
                'middleware' => [
                    TokenMiddleware::class,
                    'UserResourceMiddleware',
                    BodyParamsMiddleware::class,
                    'UserInputFilterMiddleware',
                    UpdateUserAction::class,
                ],
                'name' => 'update_user',
                'allowed_methods' => ['PUT'],
            ],
            [
                'path' => '/user/{id:\d+}',
                'middleware' => [
                    TokenMiddleware::class,
                    'UserResourceMiddleware',
                    DeleteUserAction::class
                ],
                'name' => 'delete_user',
                'allowed_methods' => ['DELETE'],
            ],
        ];
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace SlayerBirden\DataFlowServer\Domain;
5
6			use Psr\Log\LoggerInterface;
7			use SlayerBirden\DataFlowServer\Authentication\Middleware\TokenMiddleware;
8			use SlayerBirden\DataFlowServer\Doctrine\Persistence\EntityManagerRegistry;
9			use SlayerBirden\DataFlowServer\Domain\Controller\AddUserAction;
10			use SlayerBirden\DataFlowServer\Domain\Controller\DeleteUserAction;
11			use SlayerBirden\DataFlowServer\Domain\Controller\GetUserAction;
12			use SlayerBirden\DataFlowServer\Domain\Controller\GetUsersAction;
13			use SlayerBirden\DataFlowServer\Domain\Controller\UpdateUserAction;
14			use SlayerBirden\DataFlowServer\Domain\Factory\InputFilterMiddlewareFactory;
15			use SlayerBirden\DataFlowServer\Domain\Factory\UserRepositoryFactory;
16			use SlayerBirden\DataFlowServer\Domain\Factory\UserResourceMiddlewareFactory;
17			use SlayerBirden\DataFlowServer\Zend\InputFilter\ProxyFilterManagerFactory;
18			use Zend\Expressive\Helper\BodyParams\BodyParamsMiddleware;
19			use Zend\Hydrator\ClassMethods;
20			use Zend\ServiceManager\AbstractFactory\ConfigAbstractFactory;
21
22			class ConfigProvider
23			{
24			public function __invoke(): array
25			{
26			return [
27			ConfigAbstractFactory::class => $this->getAbstractFactoryConfig(),
28			'doctrine' => $this->getDoctrineConfig(),
29			'dependencies' => $this->getDependenciesConfig(),
30			'input_filter_specs' => [
31			'UserInputFilter' => $this->getUserInputFilterSpec(),
32			],
33			'routes' => $this->getRoutesConfig(),
34			];
35			}
36
37			private function getUserInputFilterSpec(): array
38			{
39			return [
40			'first' => [
41			'filters' => [
42			[
43			'name' => 'stringtrim',
44			]
45			],
46			'validators' => [
47			[
48			'name' => 'notempty',
49			],
50			[
51			'name' => 'alpha',
52			],
53			]
54			],
55			'last' => [
56			'filters' => [
57			[
58			'name' => 'stringtrim',
59			]
60			],
61			'validators' => [
62			[
63			'name' => 'notempty',
64			],
65			[
66			'name' => 'alpha',
67			],
68			]
69			],
70			'email' => [
71			'filters' => [
72			[
73			'name' => 'stringtrim',
74			]
75			],
76			'validators' => [
77			[
78			'name' => 'notempty',
79			],
80			[
81			'name' => 'emailAddress',
82			],
83			],
84			],
85			];
86			}
87
88			private function getAbstractFactoryConfig(): array
89			{
90			return [
91			AddUserAction::class => [
92			EntityManagerRegistry::class,
93			ClassMethods::class,
94			LoggerInterface::class,
95			],
96			UpdateUserAction::class => [
97			EntityManagerRegistry::class,
98			ClassMethods::class,
99			LoggerInterface::class,
100			],
101			GetUserAction::class => [
102			ClassMethods::class,
103			],
104			GetUsersAction::class => [
105			'UserRepository',
106			LoggerInterface::class,
107			ClassMethods::class,
108			],
109			DeleteUserAction::class => [
110			EntityManagerRegistry::class,
111			LoggerInterface::class,
112			ClassMethods::class,
113			],
114			];
115			}
116
117			private function getDoctrineConfig(): array
118			{
119			return [
120			'entity_managers' => [
121			'default' => [
122			'paths' => [
123			'src/Domain/Entities',
124			],
125			],
126			],
127			];
128			}
129
130			private function getDependenciesConfig(): array
131			{
132			return [
133			'factories' => [
134			'UserInputFilter' => ProxyFilterManagerFactory::class,
135			'UserResourceMiddleware' => UserResourceMiddlewareFactory::class,
136			'UserRepository' => UserRepositoryFactory::class,
137			'UserInputFilterMiddleware' => InputFilterMiddlewareFactory::class
138			],
139			];
140			}
141
142			public function getRoutesConfig(): array
143			{
144			return [
145			[
146			'path' => '/user/{id:\d+}',
147			'middleware' => [
148			TokenMiddleware::class,
149			'UserResourceMiddleware',
150			GetUserAction::class,
151			],
152			'name' => 'get_user',
153			'allowed_methods' => ['GET'],
154			],
155			[
156			'path' => '/users',
157			'middleware' => [
158			TokenMiddleware::class,
159			GetUsersAction::class,
160			],
161			'name' => 'get_users',
162			'allowed_methods' => ['GET'],
163			],
164			[
165			'path' => '/user',
166			'middleware' => [
167			TokenMiddleware::class,
168			BodyParamsMiddleware::class,
169			'UserInputFilterMiddleware',
170			AddUserAction::class,
171			],
172			'name' => 'add_user',
173			'allowed_methods' => ['POST'],
174			],
175			[
176			'path' => '/user/{id:\d+}',
177			'middleware' => [
178			TokenMiddleware::class,
179			'UserResourceMiddleware',
180			BodyParamsMiddleware::class,
181			'UserInputFilterMiddleware',
182			UpdateUserAction::class,
183			],
184			'name' => 'update_user',
185			'allowed_methods' => ['PUT'],
186			],
187			[
188			'path' => '/user/{id:\d+}',
189			'middleware' => [
190			TokenMiddleware::class,
191			'UserResourceMiddleware',
192			DeleteUserAction::class
193			],
194			'name' => 'delete_user',
195			'allowed_methods' => ['DELETE'],
196			],
197			];
198			}
199			}
200

SlayerBirden / dataflow-server

ConfigProvider::getDependenciesConfig() A last analyzed 2018-10-26 15:03 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ConfigProvider::getDependenciesConfig() A
last analyzed 2018-10-26 15:03 UTC