AdminFactory::create() - Code Metrics - Inspection of "V.1.0" - larriereguichet/AdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#90)

by Arnaud

created 2017-10-08 21:43 UTC

AdminFactory::create() A

↳ Parent: AdminFactory

Complexity

Conditions	2
Paths	2

Size

Total Lines	48
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	48
ccs	0
cts	25
cp	0
rs	9.125
c	0
b	0
f	0
cc	2
eloc	29
nc	2
nop	2
crap	6

<?php

namespace LAG\AdminBundle\Admin\Factory;

use LAG\AdminBundle\Action\Factory\ActionFactory;
use LAG\AdminBundle\Action\Registry\Registry as ActionRegistry;
use LAG\AdminBundle\Admin\AdminAwareInterface;
use LAG\AdminBundle\Admin\AdminInterface;
use LAG\AdminBundle\Admin\Configuration\AdminConfiguration;
use LAG\AdminBundle\Admin\Event\AdminCreatedEvent;
use LAG\AdminBundle\Admin\Event\AdminCreateEvent;
use LAG\AdminBundle\Admin\Event\AdminInjectedEvent;
use LAG\AdminBundle\Admin\Event\BeforeConfigurationEvent;
use LAG\AdminBundle\Admin\Registry\Registry;
use LAG\AdminBundle\Admin\Request\RequestHandler;
use LAG\AdminBundle\Configuration\Factory\ConfigurationFactory;
use LAG\AdminBundle\Admin\Event\AdminEvents;
use LAG\AdminBundle\DataProvider\Factory\DataProviderFactory;
use LAG\AdminBundle\DataProvider\Loader\EntityLoader;
use LAG\AdminBundle\Message\MessageHandlerInterface;
use LAG\AdminBundle\View\Factory\ViewFactory;
use LogicException;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;

/**
 * AdminFactory.
 *
 * This class is responsible for the creation of Admins from configuration array.
 */
class AdminFactory
{
    /**
     * @var bool
     */
    private $isInit = false;

    /**
     * @var EventDispatcherInterface
     */
    private $eventDispatcher;

    /**
     * @var ConfigurationFactory
     */
    private $configurationFactory;

    /**
     * @var AdminConfiguration[]
     */
    private $adminConfigurations;

    /**
     * @var ActionFactory
     */
    private $actionFactory;

    /**
     * @var MessageHandlerInterface
     */
    private $messageHandler;

    /**
     * @var Registry
     */
    private $adminRegistry;

    /**
     * @var DataProviderFactory
     */
    private $dataProviderFactory;
    
    /**
     * @var RequestHandler
     */
    private $requestHandler;
    
    /**
     * @var AuthorizationCheckerInterface
     */
    private $authorizationChecker;
    
    /**
     * @var TokenStorageInterface
     */
    private $tokenStorage;
    
    /**
     * @var ActionRegistry
     */
    private $actionRegistry;
    /**
     * @var ViewFactory
     */
    private $viewFactory;
    
    /**
     * AdminFactory constructor.
     *
     * @param array                         $adminConfigurations
     * @param EventDispatcherInterface      $eventDispatcher
     * @param MessageHandlerInterface       $messageHandler
     * @param Registry                      $adminRegistry
     * @param ActionRegistry                $actionRegistry
     * @param ActionFactory                 $actionFactory
     * @param ConfigurationFactory          $configurationFactory
     * @param DataProviderFactory           $dataProviderFactory
     * @param ViewFactory                   $viewFactory
     * @param RequestHandler                $requestHandler
     * @param AuthorizationCheckerInterface $authorizationChecker
     * @param TokenStorageInterface         $tokenStorage
     */
    public function __construct(

        array $adminConfigurations,
        EventDispatcherInterface $eventDispatcher,
        MessageHandlerInterface $messageHandler,
        Registry $adminRegistry,
        ActionRegistry $actionRegistry,
        ActionFactory $actionFactory,
        ConfigurationFactory $configurationFactory,
        DataProviderFactory $dataProviderFactory,
        ViewFactory $viewFactory,
        RequestHandler $requestHandler,
        AuthorizationCheckerInterface $authorizationChecker,
        TokenStorageInterface $tokenStorage
    ) {
        $this->eventDispatcher = $eventDispatcher;
        $this->configurationFactory = $configurationFactory;
        $this->adminConfigurations = $adminConfigurations;
        $this->actionFactory = $actionFactory;
        $this->messageHandler = $messageHandler;
        $this->adminRegistry = $adminRegistry;
        $this->dataProviderFactory = $dataProviderFactory;
        $this->requestHandler = $requestHandler;
        $this->authorizationChecker = $authorizationChecker;
        $this->tokenStorage = $tokenStorage;
        $this->actionRegistry = $actionRegistry;
        $this->viewFactory = $viewFactory;
    }

    /**
     * Create admins from configuration and load them into the pool. Dispatch ADMIN_CREATE event.
     */
    public function init()
    {
        // init only once
        if ($this->isInit) {
            return;
        }
        // dispatch an event to allow configuration modification before resolving and creating admins
        $event = new BeforeConfigurationEvent($this->adminConfigurations);
        $this
            ->eventDispatcher
            ->dispatch(AdminEvents::BEFORE_CONFIGURATION, $event)
        ;

        // get the modified configuration
        $this->adminConfigurations = $event->getAdminConfigurations();
        
        // create Admins according to the given configuration
        foreach ($this->adminConfigurations as $name => $configuration) {
            // dispatch an event to allow modification on a specific admin
            $event = new AdminCreateEvent($name, $configuration);
            $this
                ->eventDispatcher
                ->dispatch(AdminEvents::ADMIN_CREATE, $event)
            ;

            // create Admin object and add it to the registry
            $admin = $this->create($name, $event->getAdminConfiguration());
            $this
                ->adminRegistry
                ->add($admin)
            ;

            // dispatch post-create event
            $event = new AdminCreatedEvent($admin);
            $this
                ->eventDispatcher
                ->dispatch(AdminEvents::ADMIN_CREATED, $event)
            ;
        }
        $this->isInit = true;
    }

    /**
     * Create an Admin from configuration values. It will be added to AdminFactory admin's list.
     *
     * @param string $name
     * @param array $configuration
     *
     * @return AdminInterface
     *
     * @throws LogicException
     */
    public function create($name, array $configuration)
    {
        // create AdminConfiguration object
        $adminConfiguration = $this

            ->configurationFactory
            ->createAdminConfiguration($configuration)
        ;
        
        // retrieve a data provider and load it into the loader
        $dataProvider = $this
            ->dataProviderFactory
            ->get($adminConfiguration->getParameter('data_provider'), $adminConfiguration->getParameter('entity'))
        ;
        $entityLoader = new EntityLoader($dataProvider);
    
        // retrieve Admin dynamic class
        $adminClass = $this

            ->configurationFactory
            ->getApplicationConfiguration()
            ->getParameter('admin_class')
        ;
    
        // retrieve the actions services
        $actions = $this
            ->actionFactory
            ->getActions($name, $configuration)
        ;

        // create Admin object
        $admin = new $adminClass(
            $name,
            $entityLoader,
            $adminConfiguration,
            $this->messageHandler,
            $this->eventDispatcher,
            $this->authorizationChecker,
            $this->tokenStorage,
            $this->requestHandler,
            $this->viewFactory,
            $actions
        );
    
        if (!$admin instanceof AdminInterface) {
            throw new LogicException('Class "'.get_class($admin).'" should implements '.AdminInterface::class);
        }

        return $admin;
    }
    
    /**
     * Inject an Admin into an AdminAware controller. Add this Admin to Twig global parameters.
     *
     * @param mixed $controller
     * @param Request $request
     */
    public function injectAdmin($controller, Request $request)
    {
        // the controller should be Admin aware to have an Admin injected
        if (!$controller instanceof AdminAwareInterface) {
            return;
        }
        // get admin from the request parameters
        $admin = $this
            ->requestHandler
            ->handle($request)
        ;
        
        // inject the Admin in the controller
        $controller->setAdmin($admin);
        
        // dispatch an even to allow some custom logic
        $this
            ->eventDispatcher
            ->dispatch(AdminEvents::ADMIN_INJECTED, new AdminInjectedEvent($admin, $controller))
        ;
    }

    /**
     * Return true if the AdminFactory is initialized.
     *
     * @return boolean
     */
    public function isInit()
    {
        return $this->isInit;
    }
}


1		<?php
2
3		namespace LAG\AdminBundle\Admin\Factory;
4
5		use LAG\AdminBundle\Action\Factory\ActionFactory;
6		use LAG\AdminBundle\Action\Registry\Registry as ActionRegistry;
7		use LAG\AdminBundle\Admin\AdminAwareInterface;
8		use LAG\AdminBundle\Admin\AdminInterface;
9		use LAG\AdminBundle\Admin\Configuration\AdminConfiguration;
10		use LAG\AdminBundle\Admin\Event\AdminCreatedEvent;
11		use LAG\AdminBundle\Admin\Event\AdminCreateEvent;
12		use LAG\AdminBundle\Admin\Event\AdminInjectedEvent;
13		use LAG\AdminBundle\Admin\Event\BeforeConfigurationEvent;
14		use LAG\AdminBundle\Admin\Registry\Registry;
15		use LAG\AdminBundle\Admin\Request\RequestHandler;
16		use LAG\AdminBundle\Configuration\Factory\ConfigurationFactory;
17		use LAG\AdminBundle\Admin\Event\AdminEvents;
18		use LAG\AdminBundle\DataProvider\Factory\DataProviderFactory;
19		use LAG\AdminBundle\DataProvider\Loader\EntityLoader;
20		use LAG\AdminBundle\Message\MessageHandlerInterface;
21		use LAG\AdminBundle\View\Factory\ViewFactory;
22		use LogicException;
23		use Symfony\Component\EventDispatcher\EventDispatcherInterface;
24		use Symfony\Component\HttpFoundation\Request;
25		use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
26		use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
27
28		/**
29		* AdminFactory.
30		*
31		* This class is responsible for the creation of Admins from configuration array.
32		*/
33		class AdminFactory
34		{
35		/**
36		* @var bool
37		*/
38		private $isInit = false;
39
40		/**
41		* @var EventDispatcherInterface
42		*/
43		private $eventDispatcher;
44
45		/**
46		* @var ConfigurationFactory
47		*/
48		private $configurationFactory;
49
50		/**
51		* @var AdminConfiguration[]
52		*/
53		private $adminConfigurations;
54
55		/**
56		* @var ActionFactory
57		*/
58		private $actionFactory;
59
60		/**
61		* @var MessageHandlerInterface
62		*/
63		private $messageHandler;
64
65		/**
66		* @var Registry
67		*/
68		private $adminRegistry;
69
70		/**
71		* @var DataProviderFactory
72		*/
73		private $dataProviderFactory;
74
75		/**
76		* @var RequestHandler
77		*/
78		private $requestHandler;
79
80		/**
81		* @var AuthorizationCheckerInterface
82		*/
83		private $authorizationChecker;
84
85		/**
86		* @var TokenStorageInterface
87		*/
88		private $tokenStorage;
89
90		/**
91		* @var ActionRegistry
92		*/
93		private $actionRegistry;
94		/**
95		* @var ViewFactory
96		*/
97		private $viewFactory;
98
99		/**
100		* AdminFactory constructor.
101		*
102		* @param array $adminConfigurations
103		* @param EventDispatcherInterface $eventDispatcher
104		* @param MessageHandlerInterface $messageHandler
105		* @param Registry $adminRegistry
106		* @param ActionRegistry $actionRegistry
107		* @param ActionFactory $actionFactory
108		* @param ConfigurationFactory $configurationFactory
109		* @param DataProviderFactory $dataProviderFactory
110		* @param ViewFactory $viewFactory
111		* @param RequestHandler $requestHandler
112		* @param AuthorizationCheckerInterface $authorizationChecker
113		* @param TokenStorageInterface $tokenStorage
114		*/
115	View Code Duplication	public function __construct(
		0 ignored issues – show Duplication introduced 2017-10-08 21:39 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...
116		array $adminConfigurations,
117		EventDispatcherInterface $eventDispatcher,
118		MessageHandlerInterface $messageHandler,
119		Registry $adminRegistry,
120		ActionRegistry $actionRegistry,
121		ActionFactory $actionFactory,
122		ConfigurationFactory $configurationFactory,
123		DataProviderFactory $dataProviderFactory,
124		ViewFactory $viewFactory,
125		RequestHandler $requestHandler,
126		AuthorizationCheckerInterface $authorizationChecker,
127		TokenStorageInterface $tokenStorage
128		) {
129		$this->eventDispatcher = $eventDispatcher;
130		$this->configurationFactory = $configurationFactory;
131		$this->adminConfigurations = $adminConfigurations;
132		$this->actionFactory = $actionFactory;
133		$this->messageHandler = $messageHandler;
134		$this->adminRegistry = $adminRegistry;
135		$this->dataProviderFactory = $dataProviderFactory;
136		$this->requestHandler = $requestHandler;
137		$this->authorizationChecker = $authorizationChecker;
138		$this->tokenStorage = $tokenStorage;
139		$this->actionRegistry = $actionRegistry;
140		$this->viewFactory = $viewFactory;
141		}
142
143		/**
144		* Create admins from configuration and load them into the pool. Dispatch ADMIN_CREATE event.
145		*/
146		public function init()
147		{
148		// init only once
149		if ($this->isInit) {
150		return;
151		}
152		// dispatch an event to allow configuration modification before resolving and creating admins
153		$event = new BeforeConfigurationEvent($this->adminConfigurations);
154		$this
155		->eventDispatcher
156		->dispatch(AdminEvents::BEFORE_CONFIGURATION, $event)
157		;
158
159		// get the modified configuration
160		$this->adminConfigurations = $event->getAdminConfigurations();
161
162		// create Admins according to the given configuration
163		foreach ($this->adminConfigurations as $name => $configuration) {
164		// dispatch an event to allow modification on a specific admin
165		$event = new AdminCreateEvent($name, $configuration);
166		$this
167		->eventDispatcher
168		->dispatch(AdminEvents::ADMIN_CREATE, $event)
169		;
170
171		// create Admin object and add it to the registry
172		$admin = $this->create($name, $event->getAdminConfiguration());
173		$this
174		->adminRegistry
175		->add($admin)
176		;
177
178		// dispatch post-create event
179		$event = new AdminCreatedEvent($admin);
180		$this
181		->eventDispatcher
182		->dispatch(AdminEvents::ADMIN_CREATED, $event)
183		;
184		}
185		$this->isInit = true;
186		}
187
188		/**
189		* Create an Admin from configuration values. It will be added to AdminFactory admin's list.
190		*
191		* @param string $name
192		* @param array $configuration
193		*
194		* @return AdminInterface
195		*
196		* @throws LogicException
197		*/
198		public function create($name, array $configuration)
199		{
200		// create AdminConfiguration object
201		$adminConfiguration = $this
		0 ignored issues – show Deprecated Code introduced 2017-10-08 21:39 UTC by Report Bug Copy Issue Report The method `LAG\AdminBundle\Configur...ateAdminConfiguration()` has been deprecated. This method has been deprecated. Loading history...
202		->configurationFactory
203		->createAdminConfiguration($configuration)
204		;
205
206		// retrieve a data provider and load it into the loader
207		$dataProvider = $this
208		->dataProviderFactory
209		->get($adminConfiguration->getParameter('data_provider'), $adminConfiguration->getParameter('entity'))
210		;
211		$entityLoader = new EntityLoader($dataProvider);
212
213		// retrieve Admin dynamic class
214		$adminClass = $this
		0 ignored issues – show Deprecated Code introduced 2017-10-08 21:39 UTC by Report Bug Copy Issue Report The method `LAG\AdminBundle\Configur...licationConfiguration()` has been deprecated with message: Return the Application configuration. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
215		->configurationFactory
216		->getApplicationConfiguration()
217		->getParameter('admin_class')
218		;
219
220		// retrieve the actions services
221		$actions = $this
222		->actionFactory
223		->getActions($name, $configuration)
224		;
225
226		// create Admin object
227		$admin = new $adminClass(
228		$name,
229		$entityLoader,
230		$adminConfiguration,
231		$this->messageHandler,
232		$this->eventDispatcher,
233		$this->authorizationChecker,
234		$this->tokenStorage,
235		$this->requestHandler,
236		$this->viewFactory,
237		$actions
238		);
239
240		if (!$admin instanceof AdminInterface) {
241		throw new LogicException('Class "'.get_class($admin).'" should implements '.AdminInterface::class);
242		}
243
244		return $admin;
245		}
246
247		/**
248		* Inject an Admin into an AdminAware controller. Add this Admin to Twig global parameters.
249		*
250		* @param mixed $controller
251		* @param Request $request
252		*/
253		public function injectAdmin($controller, Request $request)
254		{
255		// the controller should be Admin aware to have an Admin injected
256		if (!$controller instanceof AdminAwareInterface) {
257		return;
258		}
259		// get admin from the request parameters
260		$admin = $this
261		->requestHandler
262		->handle($request)
263		;
264
265		// inject the Admin in the controller
266		$controller->setAdmin($admin);
267
268		// dispatch an even to allow some custom logic
269		$this
270		->eventDispatcher
271		->dispatch(AdminEvents::ADMIN_INJECTED, new AdminInjectedEvent($admin, $controller))
272		;
273		}
274
275		/**
276		* Return true if the AdminFactory is initialized.
277		*
278		* @return boolean
279		*/
280		public function isInit()
281		{
282		return $this->isInit;
283		}
284		}
285

larriereguichet / AdminBundle

Pull Request — master (#90)

AdminFactory::create() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like