Handler::getEventClass() - Code Metrics - Inspection of "Executor renamed to Hanlder" - rudestan/Teebot - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ff5597...7027db )

by Stan

created 2016-04-22 15:52 UTC

Handler::getEventClass() C

↳ Parent: Handler

Complexity

Conditions	7
Paths	7

Size

Total Lines	24
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	24
rs	6.7272
cc	7
eloc	12
nc	7
nop	1

<?php

/**
 * Event and command executor class. Goes trough entities in response object and triggers corresponding
 * entity events and/or commands, either mapped in config file or via default Teebot\Bot namespace.
 *
 * @package Teebot (Telegram bot framework)
 *
 * @author  Stanislav Drozdov <[email protected]>
 */

namespace Teebot\Command;

use Teebot\Entity\Command;
use Teebot\Entity\Error;
use Teebot\Entity\MessageEntity;
use Teebot\Entity\Update;
use Teebot\Exception\Notice;
use Teebot\Exception\Output;
use Teebot\Method\AbstractMethod;
use Teebot\Request;
use Teebot\Entity\AbstractEntity;
use Teebot\Entity\Message;
use Teebot\Entity\MessageEntityArray;
use Teebot\Config;
use Teebot\Response;

class Handler
{
    /** @var Handler */
    protected static $instance;

    /** @var Config $config */
    protected $config;

    /** @var Request $request */
    protected $request;

    /**
     * Returns a singletone instance of executor
     *
     * @return Handler
     */
    public static function getInstance()
    {
        if (!self::$instance instanceof self) {
            self::$instance = new self();
        }

        return self::$instance;
    }

    /**
     * Returns an instance of config class
     *
     * @return Config
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * Initialises the executor, creates request object
     *
     * @param Config $config Configuration object
     */
    public function initWithConfig(Config $config)
    {
        $this->config  = $config;
        $this->request = new Request($config);
    }

    /**
     * Processes array of entities from response object, root entities must be either update entity
     * or error entity in case of error response from Telegram's API.
     *
     * @param array $entities Array of entities (Update or Error) passed either from response object or
     *                        directly to the method
     *
     * @return bool
     *
     * @throws Notice
     */
    public function processEntities(array $entities)
    {
        /** @var Update $entity */
        foreach ($entities as $entity) {
            $entitiesFlow = $this->getEntitiesChain($entity);

            if (empty($entitiesFlow)) {
                throw new Notice("Unknown entity! Skipping.");
            }

            $result = $this->processEntitiesChain($entitiesFlow);

            if ($result == false) {

                throw new Notice("Failed to process the entity!");
            }
        }

        return true;
    }

    /**
     * Returns entities chain generated from nested sub-entities of the passed entity
     *
     * Generated hierarchy of the events:
     *
     * - Error
     * - Update
     *   - Message
     *     - Command
     *       - <Command name>
     *     - Audio ... <Any supported entity>
     *   - Inline Query
     *   - Chosen Inline Result
     *
     * @param Update|Error $entity Update or Error entity object
     *
     * @return array
     */
    public function getEntitiesChain($entity)
    {
        if ($entity instanceof Error) {
            return [
                ['entity' => $entity]
            ];
        }
        if (!$entity instanceof Update) {
            return [];
        }

        $updateTypeEntity = $entity->getUpdateTypeEntity();

        $events = [
            ['entity' => $entity],
            ['entity' => $updateTypeEntity, 'parent' => $updateTypeEntity],
        ];

        if ($updateTypeEntity instanceof Message && $updateTypeEntity->getMessageTypeEntity()) {

            $messageTypeEntity = $updateTypeEntity->getMessageTypeEntity();

            $events[] = [
                'entity' => $messageTypeEntity,
                'parent' => $updateTypeEntity
            ];

            if ($messageTypeEntity instanceof MessageEntityArray) {
                $entities = $messageTypeEntity->getEntities();

                foreach ($entities as $entity) {
                    $events[] = [
                        'entity' => $entity,
                        'parent' => $updateTypeEntity
                    ];
                }
            }
        }

        return $events;
    }

    /**
     * Processes generated entities chain, if triggered event returns false stops processing
     *
     * @param array $entitiesFlow Array of entities flow
     *
     * @throws Notice
     *
     * @return bool
     */
    protected function processEntitiesChain(array $entitiesFlow)
    {
        foreach ($entitiesFlow as $entityData) {

            try {
                $continue = $this->triggerEventForEntity($entityData['entity'], $entityData['parent'] ?? null);

                if (!$continue) {
                    return true;
                }
            } catch (\Exception $e) {
                Output::log($e);
            }
        }

        return true;
    }

    /**
     * Triggers desired event and returns boolean result from run method of the event. If run() returns
     * false the processing in main process method will be stopped and further events (if any)
     * will not be triggered otherwise process will continue until either first false returned or the very
     * last event in the flow.
     *
     * @param AbstractEntity $entity    Entity for which the corresponding event should be triggered
     * @param AbstractEntity $parent    Entity's parent if any
     *
     * @return bool
     */
    protected function triggerEventForEntity(AbstractEntity $entity, AbstractEntity $parent = null)
    {
        $eventClass = $this->getEventClass($entity);

        if (class_exists($eventClass)) {
            $event = new $eventClass();

            if (!$event instanceof AbstractEntityEvent && !$event instanceof AbstractCommand) {
                return true;
            }

            /** @var AbstractCommand $eventClass */
            if ($event instanceof AbstractCommand && $entity instanceof MessageEntity && $entity->isCommand()) {
                $event->setArgs($entity->getArgs());
            }

            $event->setEntity($parent ?? $entity);

            return $event->run();
        }

        return true;
    }

    /**
     * Returns mapped event class from the configuration (if it was previously defined)
     *
     * @param AbstractEntity $entity    Entity for which the corresponding event should be triggered
     *                                  be treated as a command
     * @return null|string
     */
    protected function getEventClass(AbstractEntity $entity)
    {
        $preDefinedEvents = $this->config->getEvents();
        $entityEventType  = $entity->getEntityType();

        foreach ($preDefinedEvents as $preDefinedEvent) {

            if ($preDefinedEvent['type'] == $entityEventType) {
                $className = $preDefinedEvent['class'];

                if ($entity instanceof MessageEntity && $entity->isCommand()) {
                    if (!$this->isCommandSupported($preDefinedEvent, $entity->getCommand())) {
                        continue;
                    }
                }

                if (class_exists($className)) {
                    return $className;
                }
            }
        }

        return null;
    }

    /**
     * Checks whether command is defined in config and matches the current one
     *
     * @param array  $preDefinedEvent Pre defined event data
     * @param string $command         Command name
     *
     * @return bool
     */
    protected function isCommandSupported($preDefinedEvent, $command)
    {
        return isset($preDefinedEvent['command']) && strtolower($preDefinedEvent['command']) == strtolower($command);
    }

    /**
     * Executes remote method and returns response object
     * 
     * @param AbstractMethod $method     Method instance
     * @param bool           $silentMode If set to true then the events, mapped (in config or by default)
     *                                   to the entities in the result will not be triggered
     * @param AbstractEntity $parent     Parent entity (if any)
     *
     * @return Response
     */
    public function callRemoteMethod(AbstractMethod $method, $silentMode = false, $parent = null)
    {
        /** @var Response $response */
        $response = $this->request->exec($method, $parent);

        return $this->processResponse($response, $silentMode);
    }

    /**
     * Returns a response object and starts the entities processing (if not in silent mode). Method
     * should be used only when webhook is set.
     *
     * @param string $data       Raw json data either received from php input or passed manually
     * @param bool   $silentMode If set to true then the events, mapped (in config or by default)
     *                           to the entities in the result will not be triggered
     *
     * @return Response
     */
    public function getWebhookResponse($data, $silentMode = false)
    {
        $response = new Response($data, Update::class);

        return $this->processResponse($response, $silentMode);
    }

    /**
     * Processes entities from the response object if not in silent mode or error is received.
     *
     * @param Response $response   Response object which includes entities
     * @param bool     $silentMode If set to true then the events, mapped (in config or by default)
     *                             to the entities in the result will not be triggered
     *
     * @return Response
     */
    protected function processResponse(Response $response, $silentMode = false)
    {
        if (!empty($response->getEntities()) && ($silentMode === false || $response->isErrorReceived())) {
            $this->processEntities($response->getEntities());
        }

        return $response;
    }
}


1			<?php
2
3			/**
4			* Event and command executor class. Goes trough entities in response object and triggers corresponding
5			* entity events and/or commands, either mapped in config file or via default Teebot\Bot namespace.
6			*
7			* @package Teebot (Telegram bot framework)
8			*
9			* @author Stanislav Drozdov <[email protected]>
10			*/
11
12			namespace Teebot\Command;
13
14			use Teebot\Entity\Command;
15			use Teebot\Entity\Error;
16			use Teebot\Entity\MessageEntity;
17			use Teebot\Entity\Update;
18			use Teebot\Exception\Notice;
19			use Teebot\Exception\Output;
20			use Teebot\Method\AbstractMethod;
21			use Teebot\Request;
22			use Teebot\Entity\AbstractEntity;
23			use Teebot\Entity\Message;
24			use Teebot\Entity\MessageEntityArray;
25			use Teebot\Config;
26			use Teebot\Response;
27
28			class Handler
29			{
30			/** @var Handler */
31			protected static $instance;
32
33			/** @var Config $config */
34			protected $config;
35
36			/** @var Request $request */
37			protected $request;
38
39			/**
40			* Returns a singletone instance of executor
41			*
42			* @return Handler
43			*/
44			public static function getInstance()
45			{
46			if (!self::$instance instanceof self) {
47			self::$instance = new self();
48			}
49
50			return self::$instance;
51			}
52
53			/**
54			* Returns an instance of config class
55			*
56			* @return Config
57			*/
58			public function getConfig()
59			{
60			return $this->config;
61			}
62
63			/**
64			* Initialises the executor, creates request object
65			*
66			* @param Config $config Configuration object
67			*/
68			public function initWithConfig(Config $config)
69			{
70			$this->config = $config;
71			$this->request = new Request($config);
72			}
73
74			/**
75			* Processes array of entities from response object, root entities must be either update entity
76			* or error entity in case of error response from Telegram's API.
77			*
78			* @param array $entities Array of entities (Update or Error) passed either from response object or
79			* directly to the method
80			*
81			* @return bool
82			*
83			* @throws Notice
84			*/
85			public function processEntities(array $entities)
86			{
87			/** @var Update $entity */
88			foreach ($entities as $entity) {
89			$entitiesFlow = $this->getEntitiesChain($entity);
90
91			if (empty($entitiesFlow)) {
92			throw new Notice("Unknown entity! Skipping.");
93			}
94
95			$result = $this->processEntitiesChain($entitiesFlow);
96
97			if ($result == false) {
			0 ignored issues – show Coding Style Best Practice introduced 2016-04-08 12:20 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing two booleans. Considering using the strict comparison `===` instead. When comparing two booleans, it is generally considered safer to use the strict comparison operator. Loading history...
98			throw new Notice("Failed to process the entity!");
99			}
100			}
101
102			return true;
103			}
104
105			/**
106			* Returns entities chain generated from nested sub-entities of the passed entity
107			*
108			* Generated hierarchy of the events:
109			*
110			* - Error
111			* - Update
112			* - Message
113			* - Command
114			* - <Command name>
115			* - Audio ... <Any supported entity>
116			* - Inline Query
117			* - Chosen Inline Result
118			*
119			* @param Update\|Error $entity Update or Error entity object
120			*
121			* @return array
122			*/
123			public function getEntitiesChain($entity)
124			{
125			if ($entity instanceof Error) {
126			return [
127			['entity' => $entity]
128			];
129			}
130			if (!$entity instanceof Update) {
131			return [];
132			}
133
134			$updateTypeEntity = $entity->getUpdateTypeEntity();
135
136			$events = [
137			['entity' => $entity],
138			['entity' => $updateTypeEntity, 'parent' => $updateTypeEntity],
139			];
140
141			if ($updateTypeEntity instanceof Message && $updateTypeEntity->getMessageTypeEntity()) {
142
143			$messageTypeEntity = $updateTypeEntity->getMessageTypeEntity();
144
145			$events[] = [
146			'entity' => $messageTypeEntity,
147			'parent' => $updateTypeEntity
148			];
149
150			if ($messageTypeEntity instanceof MessageEntityArray) {
151			$entities = $messageTypeEntity->getEntities();
152
153			foreach ($entities as $entity) {
154			$events[] = [
155			'entity' => $entity,
156			'parent' => $updateTypeEntity
157			];
158			}
159			}
160			}
161
162			return $events;
163			}
164
165			/**
166			* Processes generated entities chain, if triggered event returns false stops processing
167			*
168			* @param array $entitiesFlow Array of entities flow
169			*
170			* @throws Notice
171			*
172			* @return bool
173			*/
174			protected function processEntitiesChain(array $entitiesFlow)
175			{
176			foreach ($entitiesFlow as $entityData) {
177
178			try {
179			$continue = $this->triggerEventForEntity($entityData['entity'], $entityData['parent'] ?? null);
180
181			if (!$continue) {
182			return true;
183			}
184			} catch (\Exception $e) {
185			Output::log($e);
186			}
187			}
188
189			return true;
190			}
191
192			/**
193			* Triggers desired event and returns boolean result from run method of the event. If run() returns
194			* false the processing in main process method will be stopped and further events (if any)
195			* will not be triggered otherwise process will continue until either first false returned or the very
196			* last event in the flow.
197			*
198			* @param AbstractEntity $entity Entity for which the corresponding event should be triggered
199			* @param AbstractEntity $parent Entity's parent if any
200			*
201			* @return bool
202			*/
203			protected function triggerEventForEntity(AbstractEntity $entity, AbstractEntity $parent = null)
204			{
205			$eventClass = $this->getEventClass($entity);
206
207			if (class_exists($eventClass)) {
208			$event = new $eventClass();
209
210			if (!$event instanceof AbstractEntityEvent && !$event instanceof AbstractCommand) {
211			return true;
212			}
213
214			/** @var AbstractCommand $eventClass */
215			if ($event instanceof AbstractCommand && $entity instanceof MessageEntity && $entity->isCommand()) {
216			$event->setArgs($entity->getArgs());
217			}
218
219			$event->setEntity($parent ?? $entity);
220
221			return $event->run();
222			}
223
224			return true;
225			}
226
227			/**
228			* Returns mapped event class from the configuration (if it was previously defined)
229			*
230			* @param AbstractEntity $entity Entity for which the corresponding event should be triggered
231			* be treated as a command
232			* @return null\|string
233			*/
234			protected function getEventClass(AbstractEntity $entity)
235			{
236			$preDefinedEvents = $this->config->getEvents();
237			$entityEventType = $entity->getEntityType();
238
239			foreach ($preDefinedEvents as $preDefinedEvent) {
240
241			if ($preDefinedEvent['type'] == $entityEventType) {
242			$className = $preDefinedEvent['class'];
243
244			if ($entity instanceof MessageEntity && $entity->isCommand()) {
245			if (!$this->isCommandSupported($preDefinedEvent, $entity->getCommand())) {
246			continue;
247			}
248			}
249
250			if (class_exists($className)) {
251			return $className;
252			}
253			}
254			}
255
256			return null;
257			}
258
259			/**
260			* Checks whether command is defined in config and matches the current one
261			*
262			* @param array $preDefinedEvent Pre defined event data
263			* @param string $command Command name
264			*
265			* @return bool
266			*/
267			protected function isCommandSupported($preDefinedEvent, $command)
268			{
269			return isset($preDefinedEvent['command']) && strtolower($preDefinedEvent['command']) == strtolower($command);
270			}
271
272			/**
273			* Executes remote method and returns response object
274			*
275			* @param AbstractMethod $method Method instance
276			* @param bool $silentMode If set to true then the events, mapped (in config or by default)
277			* to the entities in the result will not be triggered
278			* @param AbstractEntity $parent Parent entity (if any)
279			*
280			* @return Response
281			*/
282			public function callRemoteMethod(AbstractMethod $method, $silentMode = false, $parent = null)
283			{
284			/** @var Response $response */
285			$response = $this->request->exec($method, $parent);
286
287			return $this->processResponse($response, $silentMode);
288			}
289
290			/**
291			* Returns a response object and starts the entities processing (if not in silent mode). Method
292			* should be used only when webhook is set.
293			*
294			* @param string $data Raw json data either received from php input or passed manually
295			* @param bool $silentMode If set to true then the events, mapped (in config or by default)
296			* to the entities in the result will not be triggered
297			*
298			* @return Response
299			*/
300			public function getWebhookResponse($data, $silentMode = false)
301			{
302			$response = new Response($data, Update::class);
303
304			return $this->processResponse($response, $silentMode);
305			}
306
307			/**
308			* Processes entities from the response object if not in silent mode or error is received.
309			*
310			* @param Response $response Response object which includes entities
311			* @param bool $silentMode If set to true then the events, mapped (in config or by default)
312			* to the entities in the result will not be triggered
313			*
314			* @return Response
315			*/
316			protected function processResponse(Response $response, $silentMode = false)
317			{
318			if (!empty($response->getEntities()) && ($silentMode === false \|\| $response->isErrorReceived())) {
319			$this->processEntities($response->getEntities());
320			}
321
322			return $response;
323			}
324			}
325

rudestan / Teebot

GitHub Access Token became invalid

Push — master ( ff5597...7027db )

Handler::getEventClass() C

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like