EventResolverFactory::setImpersonatingUser() - Code Metrics - Inspection of "Add impersonating user info" - xiidea/EasyAuditBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f47ecb...1c0a88 )

by Roni

created 2016-09-07 05:39 UTC

EventResolverFactory::setImpersonatingUser() A

↳ Parent: EventResolverFactory

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	6
rs	9.4285
cc	2
eloc	3
nc	2
nop	2

<?php

/*
 * This file is part of the XiideaEasyAuditBundle package.
 *
 * (c) Xiidea <http://www.xiidea.net>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Xiidea\EasyAuditBundle\Resolver;

use Symfony\Component\EventDispatcher\Event;
use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Xiidea\EasyAuditBundle\Common\UserAwareComponent;
use Xiidea\EasyAuditBundle\Entity\BaseAuditLog;
use Xiidea\EasyAuditBundle\Exception\InvalidServiceException;
use Xiidea\EasyAuditBundle\Exception\UnrecognizedEntityException;
use Xiidea\EasyAuditBundle\Exception\UnrecognizedEventInfoException;

class EventResolverFactory extends UserAwareComponent
{
    /**
     * @param Event $event
     * @param string $eventName
     * @return null|BaseAuditLog
     * @throws UnrecognizedEventInfoException
     * @throws \Exception
     */
    public function getEventLog(Event $event, $eventName)
    {
        $eventLog = $this->getEventLogObject($this->getEventLogInfo($event, $eventName));

        if ($eventLog === null) {
            return null;
        }

        $eventLog->setTypeId($eventName);
        $eventLog->setIp($this->getClientIp());
        $eventLog->setEventTime(new \DateTime());
        $this->setUser($eventLog);

        return $eventLog;
    }

    /**
     * @param $eventInfo
     *
     * @return null|BaseAuditLog
     * @throws UnrecognizedEventInfoException
     */
    protected function getEventLogObject($eventInfo)
    {
        if (empty($eventInfo)) {
            return null;
        }

        if ($eventInfo instanceof BaseAuditLog) {
            return $eventInfo;
        }

        return $this->createEventObjectFromArray($eventInfo);
    }

    /**
     * @param string $eventName
     *
     * @throws \Exception
     * @return EventResolverInterface
     */
    protected function getResolver($eventName)
    {

        if ($this->isEntityEvent($eventName)) {
            return $this->getEntityEventResolver();
        }

        $customResolvers = $this->getParameter('custom_resolvers');

        if (isset($customResolvers[$eventName])) {
            return $this->getCustomResolver($customResolvers[$eventName]);
        }

        return $this->getCommonResolver();
    }

    /**
     * @param string $eventName
     * @return bool
     */
    protected function isEntityEvent($eventName)
    {
        return in_array($eventName, $this->getDoctrineEventsList());
    }

    /**
     * @param Event $event
     * @param string $eventName
     * @return null
     * @throws InvalidServiceException
     */
    protected function getEventLogInfo(Event $event, $eventName)
    {
        if ($event instanceof EmbeddedEventResolverInterface) {
            return $event->getEventLogInfo($eventName);
        }

        if (null === $eventResolver = $this->getResolver($eventName)) {
            return null;
        }

        return $eventResolver->getEventLogInfo($event, $eventName);
    }

    /**
     * @param BaseAuditLog $entity
     * @throws \Exception
     */
    protected function setUser(BaseAuditLog $entity)
    {
        $userProperty = $this->container->getParameter('xiidea.easy_audit.user_property');

        if (null === $user = $this->getUser()) {
            $entity->setUser($this->getAnonymousUserName());
            return;
        }

        $entity->setUser($this->getSettablePropertyValue($userProperty, $user));

        $this->setImpersonatingUser($entity, $userProperty);
    }


    /**
     * @return string
     */
    protected function getClientIp()
    {
        $request = $this->getRequest();
        
        if ($request) {
            return $request->getClientIp();
        }

        return "";
    }

    /**
     * @return \Symfony\Component\DependencyInjection\ContainerInterface
     */
    protected function getContainer()
    {
        return $this->container;
    }

    /**
     * @return null
     * @throws InvalidServiceException
     */
    protected function handleInvalidResolverConfiguration()
    {
        if ($this->isDebug()) {
            throw new InvalidServiceException(
                'Resolver Service must implement' . __NAMESPACE__ . "EventResolverInterface"
            );
        }

        return null;
    }

    /**
     * @param $serviceName
     * @return null|EventResolverInterface
     * @throws InvalidServiceException
     */
    protected function getCustomResolver($serviceName)
    {
        $resolver = $this->getService($serviceName);

        if (!$resolver instanceof EventResolverInterface) {
            return $this->handleInvalidResolverConfiguration();
        }

        return $resolver;
    }

    /**
     * @param \Exception $e
     * @throws \Exception
     * @return null
     */
    protected function handleException(\Exception $e)
    {
        if ($this->isDebug()) {
            throw $e;
        }

        return null;
    }

    /**
     * @param $eventInfo
     * @return null|BaseAuditLog
     * @throws \Exception
     */
    protected function createEventObjectFromArray($eventInfo)
    {
        if (!is_array($eventInfo)) {
            return $this->handleException(new UnrecognizedEventInfoException());
        }

        $auditLogClass = $this->getParameter('entity_class');
        $eventObject = new $auditLogClass();

        if (!$eventObject instanceof BaseAuditLog) {
            return $this->handleException(new UnrecognizedEntityException());
        }

        return $eventObject->fromArray($eventInfo);
    }

    /**
     * @param $userProperty
     * @param $user
     * @return mixed
     */
    protected function getSettablePropertyValue($userProperty, $user)
    {
        if (empty($userProperty)) {
            return $user;
        }

        try {
            $propertyAccessor = PropertyAccess::createPropertyAccessor();
            return $propertyAccessor->getValue($user, $userProperty);
        } catch (NoSuchPropertyException $e) {
            return $this->handleException($e);
        }
    }

    /**
     * @param BaseAuditLog $entity
     * @param $userProperty
     */
    protected function setImpersonatingUser(BaseAuditLog $entity, $userProperty)
    {
        if (null !== $user = $this->getImpersonatingUser()) {
            $entity->setImpersonatingUser($this->getSettablePropertyValue($userProperty, $user));
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the XiideaEasyAuditBundle package.
5			*
6			* (c) Xiidea <http://www.xiidea.net>
7			*
8			* This source file is subject to the MIT license that is bundled
9			* with this source code in the file LICENSE.
10			*/
11
12			namespace Xiidea\EasyAuditBundle\Resolver;
13
14			use Symfony\Component\EventDispatcher\Event;
15			use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
16			use Symfony\Component\PropertyAccess\PropertyAccess;
17			use Xiidea\EasyAuditBundle\Common\UserAwareComponent;
18			use Xiidea\EasyAuditBundle\Entity\BaseAuditLog;
19			use Xiidea\EasyAuditBundle\Exception\InvalidServiceException;
20			use Xiidea\EasyAuditBundle\Exception\UnrecognizedEntityException;
21			use Xiidea\EasyAuditBundle\Exception\UnrecognizedEventInfoException;
22
23			class EventResolverFactory extends UserAwareComponent
24			{
25			/**
26			* @param Event $event
27			* @param string $eventName
28			* @return null\|BaseAuditLog
29			* @throws UnrecognizedEventInfoException
30			* @throws \Exception
31			*/
32			public function getEventLog(Event $event, $eventName)
33			{
34			$eventLog = $this->getEventLogObject($this->getEventLogInfo($event, $eventName));
35
36			if ($eventLog === null) {
37			return null;
38			}
39
40			$eventLog->setTypeId($eventName);
41			$eventLog->setIp($this->getClientIp());
42			$eventLog->setEventTime(new \DateTime());
43			$this->setUser($eventLog);
44
45			return $eventLog;
46			}
47
48			/**
49			* @param $eventInfo
50			*
51			* @return null\|BaseAuditLog
52			* @throws UnrecognizedEventInfoException
53			*/
54			protected function getEventLogObject($eventInfo)
55			{
56			if (empty($eventInfo)) {
57			return null;
58			}
59
60			if ($eventInfo instanceof BaseAuditLog) {
61			return $eventInfo;
62			}
63
64			return $this->createEventObjectFromArray($eventInfo);
65			}
66
67			/**
68			* @param string $eventName
69			*
70			* @throws \Exception
71			* @return EventResolverInterface
72			*/
73			protected function getResolver($eventName)
74			{
75
76			if ($this->isEntityEvent($eventName)) {
77			return $this->getEntityEventResolver();
78			}
79
80			$customResolvers = $this->getParameter('custom_resolvers');
81
82			if (isset($customResolvers[$eventName])) {
83			return $this->getCustomResolver($customResolvers[$eventName]);
84			}
85
86			return $this->getCommonResolver();
87			}
88
89			/**
90			* @param string $eventName
91			* @return bool
92			*/
93			protected function isEntityEvent($eventName)
94			{
95			return in_array($eventName, $this->getDoctrineEventsList());
96			}
97
98			/**
99			* @param Event $event
100			* @param string $eventName
101			* @return null
102			* @throws InvalidServiceException
103			*/
104			protected function getEventLogInfo(Event $event, $eventName)
105			{
106			if ($event instanceof EmbeddedEventResolverInterface) {
107			return $event->getEventLogInfo($eventName);
108			}
109
110			if (null === $eventResolver = $this->getResolver($eventName)) {
111			return null;
112			}
113
114			return $eventResolver->getEventLogInfo($event, $eventName);
115			}
116
117			/**
118			* @param BaseAuditLog $entity
119			* @throws \Exception
120			*/
121			protected function setUser(BaseAuditLog $entity)
122			{
123			$userProperty = $this->container->getParameter('xiidea.easy_audit.user_property');
124
125			if (null === $user = $this->getUser()) {
126			$entity->setUser($this->getAnonymousUserName());
127			return;
128			}
129
130			$entity->setUser($this->getSettablePropertyValue($userProperty, $user));
131
132			$this->setImpersonatingUser($entity, $userProperty);
133			}
134
135
136			/**
137			* @return string
138			*/
139			protected function getClientIp()
140			{
141			$request = $this->getRequest();
142
143			if ($request) {
144			return $request->getClientIp();
145			}
146
147			return "";
148			}
149
150			/**
151			* @return \Symfony\Component\DependencyInjection\ContainerInterface
152			*/
153			protected function getContainer()
154			{
155			return $this->container;
156			}
157
158			/**
159			* @return null
160			* @throws InvalidServiceException
161			*/
162			protected function handleInvalidResolverConfiguration()
163			{
164			if ($this->isDebug()) {
165			throw new InvalidServiceException(
166			'Resolver Service must implement' . __NAMESPACE__ . "EventResolverInterface"
167			);
168			}
169
170			return null;
171			}
172
173			/**
174			* @param $serviceName
175			* @return null\|EventResolverInterface
176			* @throws InvalidServiceException
177			*/
178			protected function getCustomResolver($serviceName)
179			{
180			$resolver = $this->getService($serviceName);
181
182			if (!$resolver instanceof EventResolverInterface) {
183			return $this->handleInvalidResolverConfiguration();
184			}
185
186			return $resolver;
187			}
188
189			/**
190			* @param \Exception $e
191			* @throws \Exception
192			* @return null
193			*/
194			protected function handleException(\Exception $e)
195			{
196			if ($this->isDebug()) {
197			throw $e;
198			}
199
200			return null;
201			}
202
203			/**
204			* @param $eventInfo
205			* @return null\|BaseAuditLog
206			* @throws \Exception
207			*/
208			protected function createEventObjectFromArray($eventInfo)
209			{
210			if (!is_array($eventInfo)) {
211			return $this->handleException(new UnrecognizedEventInfoException());
212			}
213
214			$auditLogClass = $this->getParameter('entity_class');
215			$eventObject = new $auditLogClass();
216
217			if (!$eventObject instanceof BaseAuditLog) {
218			return $this->handleException(new UnrecognizedEntityException());
219			}
220
221			return $eventObject->fromArray($eventInfo);
222			}
223
224			/**
225			* @param $userProperty
226			* @param $user
227			* @return mixed
228			*/
229			protected function getSettablePropertyValue($userProperty, $user)
230			{
231			if (empty($userProperty)) {
232			return $user;
233			}
234
235			try {
236			$propertyAccessor = PropertyAccess::createPropertyAccessor();
237			return $propertyAccessor->getValue($user, $userProperty);
238			} catch (NoSuchPropertyException $e) {
239			return $this->handleException($e);
240			}
241			}
242
243			/**
244			* @param BaseAuditLog $entity
245			* @param $userProperty
246			*/
247			protected function setImpersonatingUser(BaseAuditLog $entity, $userProperty)
248			{
249			if (null !== $user = $this->getImpersonatingUser()) {
250			$entity->setImpersonatingUser($this->getSettablePropertyValue($userProperty, $user));
251			}
252			}
253			}
254

xiidea / EasyAuditBundle

Push — master ( f47ecb...1c0a88 )

EventResolverFactory::setImpersonatingUser() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like