Admin::__construct() - Code Metrics - Inspection of "Fix bug in edit action due to wrong offset" - larriereguichet/AdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — dev ( 86d4c7...e07520 )

by Arnaud

created 2016-08-02 22:15 UTC

Admin::__construct() A

↳ Parent: Admin

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	1

Importance

Changes	7
Bugs	1	Features	2

Metric	Value
c	7
b	1
f	2
dl	0
loc	12
ccs	7
cts	7
cp	1
rs	9.4285
cc	1
eloc	10
nc	1
nop	4
crap	1

<?php

namespace LAG\AdminBundle\Admin;

use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\EntityManagerInterface;
use LAG\AdminBundle\Action\ActionInterface;
use LAG\AdminBundle\Admin\Behaviors\AdminTrait;
use LAG\AdminBundle\Admin\Configuration\AdminConfiguration;
use Doctrine\Common\Collections\ArrayCollection;
use Exception;
use LAG\AdminBundle\DataProvider\DataProviderInterface;
use LAG\AdminBundle\Exception\AdminException;
use LAG\AdminBundle\Filter\PagerfantaFilter;
use LAG\AdminBundle\Filter\RequestFilter;
use LAG\AdminBundle\Message\MessageHandlerInterface;
use LAG\AdminBundle\Pager\PagerFantaAdminAdapter;
use Pagerfanta\Pagerfanta;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Security\Core\Role\Role;
use Symfony\Component\Security\Core\User\UserInterface;

class Admin implements AdminInterface
{
    use AdminTrait;

    /**
     * Entities collection.
     *
     * @var ArrayCollection
     */
    protected $entities;

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

    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;

    /**
     * @var DataProviderInterface
     */
    protected $dataProvider;

    /**
     * Admin configuration object
     *
     * @var AdminConfiguration
     */
    protected $configuration;

    /**
     * Admin configured actions
     *
     * @var ActionInterface[]
     */
    protected $actions = [];

    /**
     * Admin current action. It will be set after calling the handleRequest()
     *
     * @var ActionInterface
     */
    protected $currentAction;

    /**
     * Admin name
     *
     * @var string
     */
    protected $name;

    /**
     * Admin constructor.
     *
     * @param string $name
     * @param DataProviderInterface $dataProvider
     * @param AdminConfiguration $configuration
     * @param MessageHandlerInterface $messageHandler
     */
    public function __construct(
        $name,
        DataProviderInterface $dataProvider,
        AdminConfiguration $configuration,
        MessageHandlerInterface $messageHandler
    ) {
        $this->name = $name;
        $this->dataProvider = $dataProvider;
        $this->configuration = $configuration;
        $this->messageHandler = $messageHandler;
        $this->entities = new ArrayCollection();
    }

    /**
     * Load entities and set current action according to request
     *
     * @param Request $request
     * @param null $user
     * @return void
     * @throws AdminException
     */
    public function handleRequest(Request $request, $user = null)
    {
        // set current action
        $this->currentAction = $this->getAction($request->get('_route_params')['_action']);
        // check if user is logged have required permissions to get current action
        $this->checkPermissions($user);

        // criteria filter request
        $filter = new RequestFilter($this->currentAction->getConfiguration()->getParameter('criteria'));
        $criteriaFilter = $filter->filter($request);

        // pager filter request
        if ($this->currentAction->getConfiguration()->getParameter('pager') == 'pagerfanta') {
            $filter = new PagerfantaFilter();
            $pagerFilter = $filter->filter($request);
        } else {
            // empty bag
            $pagerFilter = new ParameterBag();
        }

        // if load strategy is none, no entity should be loaded
        if ($this->currentAction->getConfiguration()->getParameter('load_strategy') == Admin::LOAD_STRATEGY_NONE) {
            return;
        }

        // load entities according to action and request
        $this->load(
            $criteriaFilter->all(),
            $pagerFilter->get('order', []),
            $this->configuration->getParameter('max_per_page'),
            $pagerFilter->get('page', 1)
        );
    }

    /**
     * Check if user is allowed to be here
     *
     * @param UserInterface|string $user
     * @throws Exception
     */
    public function checkPermissions($user)
    {
        if (!($user instanceof UserInterface)) {
            return;
        }
        if ($this->currentAction === null) {
            throw new Exception('Current action should be set before checking the permissions');
        }
        $roles = $user->getRoles();
        $actionName = $this
            ->getCurrentAction()
            ->getName();

        if (!$this->isActionGranted($actionName, $roles)) {
            $rolesStringArray = [];

            foreach ($roles as $role) {

                if ($role instanceof Role) {
                    $rolesStringArray[] = $role->getRole();
                } else {
                    $rolesStringArray[] = $role;
                }
            }

            $message = sprintf('User with roles %s not allowed for action "%s"',
                implode(', ', $rolesStringArray),
                $actionName
            );
            throw new NotFoundHttpException($message);
        }
    }

    /**
     * Create and return a new entity.
     *
     * @return object
     */
    public function create()
    {
        // create an entity from the data provider
        $entity = $this
            ->dataProvider
            ->create();

        // add it to the collection
        $this
            ->entities
            ->add($entity);

        // inform the user that  the entity is created
        $this
            ->messageHandler
            ->handleSuccess($this->generateMessageTranslationKey('created'));

        return $entity;
    }

    /**
     * Save entity via admin manager. Error are catch, logged and a flash message is added to session
     *
     * @return bool true if the entity was saved without errors
     */
    public function save()
    {
        try {
            foreach ($this->entities as $entity) {
                $this
                    ->dataProvider
                    ->save($entity);
            }
            // inform the user that the entity is saved
            $this
                ->messageHandler
                ->handleSuccess($this->generateMessageTranslationKey('lag.admin.'.$this->name.'.saved'));
            $success = true;
        } catch (Exception $e) {
            $this
                ->messageHandler
                ->handleError(
                    $this->generateMessageTranslationKey('lag.admin.saved_errors'),
                    "An error has occurred while saving an entity : {$e->getMessage()}, stackTrace: {$e->getTraceAsString()}"
                );
            $success = false;
        }
        return $success;
    }

    /**
     * Remove an entity with data provider
     *
     * @return bool true if the entity was saved without errors
     */
    public function remove()
    {
        try {
            foreach ($this->entities as $entity) {
                $this
                    ->dataProvider
                    ->remove($entity);
            }
            // inform the user that the entity is removed
            $this
                ->messageHandler
                ->handleSuccess($this->generateMessageTranslationKey('lag.admin.'.$this->name.'.deleted'));
            $success = true;
        } catch (Exception $e) {
            $this
                ->messageHandler
                ->handleError(
                    $this->generateMessageTranslationKey('lag.admin.deleted_errors'),
                    "An error has occurred while deleting an entity : {$e->getMessage()}, stackTrace: {$e->getTraceAsString()} "
                );
            $success = false;
        }
        return $success;
    }

    /**
     * Generate a route for admin and action name (like lag.admin.my_admin)
     *
     * @param $actionName
     *
     * @return string
     *
     * @throws Exception
     */
    public function generateRouteName($actionName)
    {
        if (!array_key_exists($actionName, $this->getConfiguration()->getParameter('actions'))) {
            throw new Exception(
                sprintf('Invalid action name %s for admin %s (available action are: %s)',
                    $actionName,
                    $this->getName(),
                    implode(', ', $this->getActionNames()))
            );
        }
        // get routing name pattern
        $routingPattern = $this->getConfiguration()->getParameter('routing_name_pattern');
        // replace admin and action name in pattern
        $routeName = str_replace('{admin}', Container::underscore($this->getName()), $routingPattern);
        $routeName = str_replace('{action}', $actionName, $routeName);

        return $routeName;
    }

    /**
     * Load entities manually according to criteria.
     *
     * @param array $criteria
     * @param array $orderBy
     * @param int $limit
     * @param int $offset
     * @throws Exception
     */
    public function load(array $criteria, $orderBy = [], $limit = 25, $offset = 1)
    {
        $actionConfiguration = $this
            ->getCurrentAction()
            ->getConfiguration();
        $pager = $actionConfiguration->getParameter('pager');
        $requirePagination = $this
            ->getCurrentAction()
            ->requirePagination();

        if ($pager == 'pagerfanta' && $requirePagination) {
            // adapter to pagerfanta
            $adapter = new PagerFantaAdminAdapter($this->dataProvider, $criteria, $orderBy);
            // create pager
            $this->pager = new Pagerfanta($adapter);
            $this->pager->setMaxPerPage($limit);
            $this->pager->setCurrentPage($offset);

            $entities = $this
                ->pager
                ->getCurrentPageResults();
        } else {
            // if the current action should retrieve only one entity, the offset should be zero
            if ($actionConfiguration->getParameter('load_strategy') !== AdminInterface::LOAD_STRATEGY_MULTIPLE) {
                $offset = 0;
            }
            $entities = $this
                ->dataProvider
                ->findBy($criteria, $orderBy, $limit, $offset);
        }
        if (!is_array($entities) && !($entities instanceof Collection)) {
            throw new Exception('The data provider should return either a collection or an array. Got '.gettype($entities).' instead');
        }

        if (is_array($entities)) {
            $entities = new ArrayCollection($entities);
        }
        $this->entities = $entities;
    }

    /**
     * Return loaded entities
     *
     * @return Collection
     */
    public function getEntities()
    {
        return $this->entities;
    }

    /**
     * Return entity for current admin. If entity does not exist, it throws an exception.
     *
     * @return mixed
     *
     * @throws Exception
     */
    public function getUniqueEntity()
    {
        if ($this->entities->count() == 0) {
            throw new Exception("Entity not found in admin \"{$this->getName()}\".");
        }
        if ($this->entities->count() > 1) {
            throw new Exception("Too much entities found in admin \"{$this->getName()}\".");
        }
        return $this->entities->first();
    }

    /**
     * Return admin name
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Return true if current action is granted for user.
     *
     * @param string $actionName Le plus grand de tous les héros
     * @param array $roles
     *
     * @return bool
     */
    public function isActionGranted($actionName, array $roles)
    {
        $isGranted = array_key_exists($actionName, $this->actions);

        // if action exists
        if ($isGranted) {
            $isGranted = false;
            /** @var ActionInterface $action */
            $action = $this->actions[$actionName];
            // checking roles permissions
            foreach ($roles as $role) {

                if ($role instanceof Role) {
                    $role = $role->getRole();
                }
                if (in_array($role, $action->getPermissions())) {
                    $isGranted = true;
                }
            }
        }

        return $isGranted;
    }

    /**
     * @return ActionInterface[]
     */
    public function getActions()
    {
        return $this->actions;
    }

    /**
     * @return integer[]
     */
    public function getActionNames()
    {
        return array_keys($this->actions);
    }

    /**
     * @param $name
     * @return ActionInterface
     * @throws Exception
     */
    public function getAction($name)
    {
        if (!array_key_exists($name, $this->getActions())) {
            throw new Exception(
                "Invalid action name \"{$name}\" for admin '{$this->getName()}'. Check your configuration"
            );
        }

        return $this->actions[$name];
    }

    /**
     * Return if an action with specified name exists form this admin.
     *
     * @param $name
     * @return bool
     */
    public function hasAction($name)
    {
        return array_key_exists($name, $this->actions);
    }

    /**
     * @param ActionInterface $action
     * @return void
     */
    public function addAction(ActionInterface $action)
    {
        $this->actions[$action->getName()] = $action;
    }

    /**
     * Return the current action or an exception if it is not set.
     *
     * @return ActionInterface
     * @throws Exception
     */
    public function getCurrentAction()
    {
        if ($this->currentAction === null) {
            // current action should be defined
            throw new Exception(
                'Current action is null. You should initialize it (with handleRequest method for example)'
            );
        }

        return $this->currentAction;
    }

    /**
     * Return if the current action has been initialized and set.
     *
     * @return boolean
     */
    public function isCurrentActionDefined()
    {
        return ($this->currentAction instanceof ActionInterface);
    }

    /**
     * Return admin configuration object.
     *
     * @return AdminConfiguration
     */
    public function getConfiguration()
    {
        return $this->configuration;
    }

    /**
     * Return an translation key for a message according to the Admin's translation pattern.
     *
     * @param string $message
     * @return string
     */
    protected function generateMessageTranslationKey($message)
    {
        return $this->getTranslationKey(
            $this->configuration->getParameter('translation_pattern'),
            $message,
            $this->name
        );
    }
}


1			<?php
2
3			namespace LAG\AdminBundle\Admin;
4
5			use Doctrine\Common\Collections\Collection;
6			use Doctrine\ORM\EntityManagerInterface;
7			use LAG\AdminBundle\Action\ActionInterface;
8			use LAG\AdminBundle\Admin\Behaviors\AdminTrait;
9			use LAG\AdminBundle\Admin\Configuration\AdminConfiguration;
10			use Doctrine\Common\Collections\ArrayCollection;
11			use Exception;
12			use LAG\AdminBundle\DataProvider\DataProviderInterface;
13			use LAG\AdminBundle\Exception\AdminException;
14			use LAG\AdminBundle\Filter\PagerfantaFilter;
15			use LAG\AdminBundle\Filter\RequestFilter;
16			use LAG\AdminBundle\Message\MessageHandlerInterface;
17			use LAG\AdminBundle\Pager\PagerFantaAdminAdapter;
18			use Pagerfanta\Pagerfanta;
19			use Symfony\Component\DependencyInjection\Container;
20			use Symfony\Component\HttpFoundation\ParameterBag;
21			use Symfony\Component\HttpFoundation\Request;
22			use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
23			use Symfony\Component\Security\Core\Role\Role;
24			use Symfony\Component\Security\Core\User\UserInterface;
25
26			class Admin implements AdminInterface
27			{
28			use AdminTrait;
29
30			/**
31			* Entities collection.
32			*
33			* @var ArrayCollection
34			*/
35			protected $entities;
36
37			/**
38			* @var MessageHandlerInterface
39			*/
40			protected $messageHandler;
41
42			/**
43			* @var EntityManagerInterface
44			*/
45			protected $entityManager;
46
47			/**
48			* @var DataProviderInterface
49			*/
50			protected $dataProvider;
51
52			/**
53			* Admin configuration object
54			*
55			* @var AdminConfiguration
56			*/
57			protected $configuration;
58
59			/**
60			* Admin configured actions
61			*
62			* @var ActionInterface[]
63			*/
64			protected $actions = [];
65
66			/**
67			* Admin current action. It will be set after calling the handleRequest()
68			*
69			* @var ActionInterface
70			*/
71			protected $currentAction;
72
73			/**
74			* Admin name
75			*
76			* @var string
77			*/
78			protected $name;
79
80			/**
81			* Admin constructor.
82			*
83			* @param string $name
84			* @param DataProviderInterface $dataProvider
85			* @param AdminConfiguration $configuration
86			* @param MessageHandlerInterface $messageHandler
87			*/
88	19		public function __construct(
89			$name,
90			DataProviderInterface $dataProvider,
91			AdminConfiguration $configuration,
92			MessageHandlerInterface $messageHandler
93			) {
94	19		$this->name = $name;
95	19		$this->dataProvider = $dataProvider;
96	19		$this->configuration = $configuration;
97	19		$this->messageHandler = $messageHandler;
98	19		$this->entities = new ArrayCollection();
99	19		}
100
101			/**
102			* Load entities and set current action according to request
103			*
104			* @param Request $request
105			* @param null $user
106			* @return void
107			* @throws AdminException
108			*/
109	6		public function handleRequest(Request $request, $user = null)
110			{
111			// set current action
112	6		$this->currentAction = $this->getAction($request->get('_route_params')['_action']);
113			// check if user is logged have required permissions to get current action
114	6		$this->checkPermissions($user);
115
116			// criteria filter request
117	6		$filter = new RequestFilter($this->currentAction->getConfiguration()->getParameter('criteria'));
118	6		$criteriaFilter = $filter->filter($request);
119
120			// pager filter request
121	6		if ($this->currentAction->getConfiguration()->getParameter('pager') == 'pagerfanta') {
122	5		$filter = new PagerfantaFilter();
123	5		$pagerFilter = $filter->filter($request);
124	5		} else {
125			// empty bag
126	1		$pagerFilter = new ParameterBag();
127			}
128
129			// if load strategy is none, no entity should be loaded
130	6		if ($this->currentAction->getConfiguration()->getParameter('load_strategy') == Admin::LOAD_STRATEGY_NONE) {
131	1		return;
132			}
133
134			// load entities according to action and request
135	6		$this->load(
136	6		$criteriaFilter->all(),
137	6		$pagerFilter->get('order', []),
138	6		$this->configuration->getParameter('max_per_page'),
139	6		$pagerFilter->get('page', 1)
140	6		);
141	6		}
142
143			/**
144			* Check if user is allowed to be here
145			*
146			* @param UserInterface\|string $user
147			* @throws Exception
148			*/
149	6		public function checkPermissions($user)
150			{
151	6		if (!($user instanceof UserInterface)) {
152	6		return;
153			}
154	1		if ($this->currentAction === null) {
155	1		throw new Exception('Current action should be set before checking the permissions');
156			}
157	1		$roles = $user->getRoles();
158	1		$actionName = $this
159	1		->getCurrentAction()
160	1		->getName();
161
162	1		if (!$this->isActionGranted($actionName, $roles)) {
163	1		$rolesStringArray = [];
164
165	1		foreach ($roles as $role) {
166
167	1		if ($role instanceof Role) {
168	1		$rolesStringArray[] = $role->getRole();
169	1		} else {
170	1		$rolesStringArray[] = $role;
171			}
172	1		}
173
174	1		$message = sprintf('User with roles %s not allowed for action "%s"',
175	1		implode(', ', $rolesStringArray),
176			$actionName
177	1		);
178	1		throw new NotFoundHttpException($message);
179			}
180	1		}
181
182			/**
183			* Create and return a new entity.
184			*
185			* @return object
186			*/
187	3		public function create()
188			{
189			// create an entity from the data provider
190	3		$entity = $this
191			->dataProvider
192	3		->create();
193
194			// add it to the collection
195	3		$this
196			->entities
197	3		->add($entity);
198
199			// inform the user that the entity is created
200	3		$this
201			->messageHandler
202	3		->handleSuccess($this->generateMessageTranslationKey('created'));
203
204	3		return $entity;
205			}
206
207			/**
208			* Save entity via admin manager. Error are catch, logged and a flash message is added to session
209			*
210			* @return bool true if the entity was saved without errors
211			*/
212	1	View Code Duplication	public function save()
213			{
214			try {
215	1		foreach ($this->entities as $entity) {
216	1		$this
217			->dataProvider
218	1		->save($entity);
219	1		}
220			// inform the user that the entity is saved
221	1		$this
222			->messageHandler
223	1		->handleSuccess($this->generateMessageTranslationKey('lag.admin.'.$this->name.'.saved'));
224	1		$success = true;
225	1		} catch (Exception $e) {
226	1		$this
227			->messageHandler
228	1		->handleError(
229	1		$this->generateMessageTranslationKey('lag.admin.saved_errors'),
230	1		"An error has occurred while saving an entity : {$e->getMessage()}, stackTrace: {$e->getTraceAsString()}"
231	1		);
232	1		$success = false;
233			}
234	1		return $success;
235			}
236
237			/**
238			* Remove an entity with data provider
239			*
240			* @return bool true if the entity was saved without errors
241			*/
242	1	View Code Duplication	public function remove()
243			{
244			try {
245	1		foreach ($this->entities as $entity) {
246	1		$this
247			->dataProvider
248	1		->remove($entity);
249	1		}
250			// inform the user that the entity is removed
251	1		$this
252			->messageHandler
253	1		->handleSuccess($this->generateMessageTranslationKey('lag.admin.'.$this->name.'.deleted'));
254	1		$success = true;
255	1		} catch (Exception $e) {
256	1		$this
257			->messageHandler
258	1		->handleError(
259	1		$this->generateMessageTranslationKey('lag.admin.deleted_errors'),
260	1		"An error has occurred while deleting an entity : {$e->getMessage()}, stackTrace: {$e->getTraceAsString()} "
261	1		);
262	1		$success = false;
263			}
264	1		return $success;
265			}
266
267			/**
268			* Generate a route for admin and action name (like lag.admin.my_admin)
269			*
270			* @param $actionName
271			*
272			* @return string
273			*
274			* @throws Exception
275			*/
276	10		public function generateRouteName($actionName)
277			{
278	10		if (!array_key_exists($actionName, $this->getConfiguration()->getParameter('actions'))) {
279	2		throw new Exception(
280	2		sprintf('Invalid action name %s for admin %s (available action are: %s)',
281	2		$actionName,
282	2		$this->getName(),
283	2		implode(', ', $this->getActionNames()))
284	2		);
285			}
286			// get routing name pattern
287	10		$routingPattern = $this->getConfiguration()->getParameter('routing_name_pattern');
288			// replace admin and action name in pattern
289	10		$routeName = str_replace('{admin}', Container::underscore($this->getName()), $routingPattern);
290	10		$routeName = str_replace('{action}', $actionName, $routeName);
291
292	10		return $routeName;
293			}
294
295			/**
296			* Load entities manually according to criteria.
297			*
298			* @param array $criteria
299			* @param array $orderBy
300			* @param int $limit
301			* @param int $offset
302			* @throws Exception
303			*/
304	6		public function load(array $criteria, $orderBy = [], $limit = 25, $offset = 1)
305			{
306	6		$actionConfiguration = $this
307	6		->getCurrentAction()
308	6		->getConfiguration();
309	6		$pager = $actionConfiguration->getParameter('pager');
310			$requirePagination = $this
311	6		->getCurrentAction()
312			->requirePagination();
313	5
314			if ($pager == 'pagerfanta' && $requirePagination) {
315	5		// adapter to pagerfanta
316	5		$adapter = new PagerFantaAdminAdapter($this->dataProvider, $criteria, $orderBy);
317	5		// create pager
318			$this->pager = new Pagerfanta($adapter);
319	5		$this->pager->setMaxPerPage($limit);
320			$this->pager->setCurrentPage($offset);
321	5
322	5		$entities = $this
323	1		->pager
324			->getCurrentPageResults();
325	1		} else {
326			// if the current action should retrieve only one entity, the offset should be zero
327	6		if ($actionConfiguration->getParameter('load_strategy') !== AdminInterface::LOAD_STRATEGY_MULTIPLE) {
328	1		$offset = 0;
329			}
330			$entities = $this
331	6		->dataProvider
332	6		->findBy($criteria, $orderBy, $limit, $offset);
333	6		}
334	6		if (!is_array($entities) && !($entities instanceof Collection)) {
335	6		throw new Exception('The data provider should return either a collection or an array. Got '.gettype($entities).' instead');
336			}
337
338			if (is_array($entities)) {
339			$entities = new ArrayCollection($entities);
340			}
341			$this->entities = $entities;
342	2		}
343
344	2		/**
345			* Return loaded entities
346			*
347			* @return Collection
348			*/
349			public function getEntities()
350			{
351			return $this->entities;
352			}
353
354	1		/**
355			* Return entity for current admin. If entity does not exist, it throws an exception.
356	1		*
357	1		* @return mixed
358			*
359	1		* @throws Exception
360	1		*/
361			public function getUniqueEntity()
362	1		{
363			if ($this->entities->count() == 0) {
364			throw new Exception("Entity not found in admin \"{$this->getName()}\".");
365			}
366			if ($this->entities->count() > 1) {
367			throw new Exception("Too much entities found in admin \"{$this->getName()}\".");
368			}
369			return $this->entities->first();
370	16		}
371
372	16		/**
373			* Return admin name
374			*
375			* @return string
376			*/
377			public function getName()
378			{
379			return $this->name;
380			}
381
382			/**
383	2		* Return true if current action is granted for user.
384			*
385	2		* @param string $actionName Le plus grand de tous les héros
386			* @param array $roles
387			*
388	2		* @return bool
389	2		*/
390			public function isActionGranted($actionName, array $roles)
391	2		{
392			$isGranted = array_key_exists($actionName, $this->actions);
393	2
394			// if action exists
395	2		if ($isGranted) {
396	2		$isGranted = false;
397	2		/** @var ActionInterface $action */
398	2		$action = $this->actions[$actionName];
399	2		// checking roles permissions
400	2		foreach ($roles as $role) {
401	2
402	2		if ($role instanceof Role) {
403			$role = $role->getRole();
404	2		}
405			if (in_array($role, $action->getPermissions())) {
406			$isGranted = true;
407			}
408			}
409			}
410	7
411			return $isGranted;
412	7		}
413
414			/**
415			* @return ActionInterface[]
416			*/
417			public function getActions()
418	2		{
419			return $this->actions;
420	2		}
421
422			/**
423			* @return integer[]
424			*/
425			public function getActionNames()
426			{
427			return array_keys($this->actions);
428	6		}
429
430	6		/**
431	1		* @param $name
432	1		* @return ActionInterface
433	1		* @throws Exception
434			*/
435			public function getAction($name)
436	6		{
437			if (!array_key_exists($name, $this->getActions())) {
438			throw new Exception(
439			"Invalid action name \"{$name}\" for admin '{$this->getName()}'. Check your configuration"
440			);
441			}
442
443			return $this->actions[$name];
444			}
445	1
446			/**
447	1		* Return if an action with specified name exists form this admin.
448			*
449			* @param $name
450			* @return bool
451			*/
452			public function hasAction($name)
453			{
454	14		return array_key_exists($name, $this->actions);
455			}
456	14
457	14		/**
458			* @param ActionInterface $action
459			* @return void
460			*/
461			public function addAction(ActionInterface $action)
462			{
463			$this->actions[$action->getName()] = $action;
464			}
465	7
466			/**
467	7		* Return the current action or an exception if it is not set.
468			*
469	1		* @return ActionInterface
470			* @throws Exception
471	1		*/
472			public function getCurrentAction()
473			{
474	6		if ($this->currentAction === null) {
475			// current action should be defined
476			throw new Exception(
477			'Current action is null. You should initialize it (with handleRequest method for example)'
478			);
479			}
480
481			return $this->currentAction;
482	1		}
483
484	1		/**
485			* Return if the current action has been initialized and set.
486			*
487			* @return boolean
488			*/
489			public function isCurrentActionDefined()
490			{
491			return ($this->currentAction instanceof ActionInterface);
492	16		}
493
494	16		/**
495			* Return admin configuration object.
496			*
497			* @return AdminConfiguration
498			*/
499			public function getConfiguration()
500			{
501			return $this->configuration;
502			}
503	3
504			/**
505	3		* Return an translation key for a message according to the Admin's translation pattern.
506	3		*
507	3		* @param string $message
508	3		* @return string
509	3		*/
510			protected function generateMessageTranslationKey($message)
511			{
512			return $this->getTranslationKey(
513			$this->configuration->getParameter('translation_pattern'),
514			$message,
515			$this->name
516			);
517			}
518			}
519

larriereguichet / AdminBundle

Push — dev ( 86d4c7...e07520 )

Admin::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like