Broadcast::setEntityManager() - Code Metrics - Inspection of "Fixes" - sfcod/socketio - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 51c7de...741841 )

by Alexey

created 2020-03-26 15:07 UTC

Broadcast::setEntityManager() A

↳ Parent: Broadcast

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

namespace SfCod\SocketIoBundle\Service;

use Doctrine\ORM\EntityManagerInterface;
use Exception;
use HTMLPurifier;
use Psr\Log\LoggerInterface;
use SfCod\SocketIoBundle\Events\EventInterface;
use SfCod\SocketIoBundle\events\EventPolicyInterface;
use SfCod\SocketIoBundle\Events\EventPublisherInterface;
use SfCod\SocketIoBundle\events\EventRoomInterface;
use SfCod\SocketIoBundle\Events\EventSubscriberInterface;

/**
 * Class Broadcast.
 *
 * @package SfCod\SocketIoBundle
 */
class Broadcast
{
    /**
     * @var array
     */
    protected static $channels = [];
    /**
     * @var RedisDriver
     */
    protected $redis;
    /**
     * @var LoggerInterface
     */
    protected $logger;
    /**
     * @var EventManager
     */
    protected $manager;
    /**
     * @var Process
     */
    protected $process;
    /**
     * @var EntityManagerInterface
     */
    protected $entityManager;

    /**
     * Broadcast constructor.
     */
    public function __construct(RedisDriver $redis, EventManager $manager, LoggerInterface $logger, Process $process)
    {
        $this->redis = $redis;
        $this->logger = $logger;
        $this->manager = $manager;
        $this->process = $process;
    }

    /**
     * Subscribe to event from client.
     *
     * @return \Symfony\Component\Process\Process
     *
     * @throws Exception
     */
    public function on(string $event, array $data)
    {
        // Clear data
        array_walk_recursive($data, function (&$item, $key) {

            $item = (new HtmlPurifier())->purify($item);
        });

        $this->logger->info(json_encode(['type' => 'on', 'name' => $event, 'data' => $data]));

        return $this->process->run($event, $data);
    }

    /**
     * Run process.
     */
    public function process(string $handler, array $data)
    {
        try {
            /** @var EventInterface|EventSubscriberInterface|EventPolicyInterface $eventHandler */
            $eventHandler = $this->manager->resolve($handler); //container->get(sprintf('socketio.%s', $handler));

            if (false === $eventHandler instanceof EventInterface) {
                throw new Exception('Event should implement EventInterface');
            }

            $eventHandler->setPayload($data);

            if (false === $eventHandler instanceof EventSubscriberInterface) {
                throw new Exception('Event should implement EventSubscriberInterface');
            }

            if (true === $eventHandler instanceof EventPolicyInterface && false === $eventHandler->can($data)) {
                return;
            }

            if ($this->entityManager) {
                $connection = $this->entityManager->getConnection();
                $connection->close();
                $connection->connect();
            }

            $this->logger->info(json_encode(['type' => 'process', 'name' => $handler, 'data' => $data]));

            $eventHandler->handle();
        } catch (Exception $e) {
            $this->logger->error($e);
        }
    }

    /**
     * Emit event to client.
     *
     * @throws Exception
     */
    public function emit(string $event, array $data)
    {
        $this->logger->info(json_encode(['type' => 'emit', 'name' => $event, 'data' => $data]));

        try {
            /** @var EventInterface|EventPublisherInterface|EventRoomInterface $eventHandler */
            $eventHandler = $this->manager->resolve($event); // container->get(sprintf('socketio.%s', $event));

            if (false === $eventHandler instanceof EventInterface) {
                throw new Exception('Event should implement EventInterface');
            }

            $eventHandler->setPayload($data);

            if (false === $eventHandler instanceof EventPublisherInterface) {
                throw new Exception('Event should implement EventPublisherInterface');
            }

            $data = $eventHandler->fire();

            if ($eventHandler instanceof EventRoomInterface) {
                $data['room'] = $eventHandler->room();
            }

            $eventHandlerClass = get_class($eventHandler);
            foreach ($eventHandlerClass::broadcastOn() as $channel) {
                $this->publish($this->channelName($channel), [
                    'name' => $eventHandlerClass::name(),
                    'data' => $data,
                ]);
            }
        } catch (Exception $e) {
            $this->logger->error($e);
        }
    }

    /**
     * Publish data to redis channel.
     */
    protected function publish(string $channel, array $data)
    {
        $this->redis->getClient(true)->publish($channel, json_encode($data));
    }

    /**
     * Prepare channel name.
     */
    protected function channelName(string $name): string
    {
        return $name . getenv('SOCKET_IO_NSP');
    }

    /**
     * Redis channels names.
     */
    public function channels(): array
    {
        if (empty(self::$channels)) {
            foreach ($this->manager->getList() as $eventHandlerClass) {
                self::$channels = array_merge(self::$channels, $eventHandlerClass::broadcastOn());
            }
            self::$channels = array_unique(self::$channels);
            self::$channels = array_map(function ($channel) {
                return $this->channelName($channel);
            }, self::$channels);
        }

        return self::$channels;
    }

    public function setEntityManager(EntityManagerInterface $entityManager)
    {
        $this->entityManager = $entityManager;
    }
}


1			<?php
2
3			namespace SfCod\SocketIoBundle\Service;
4
5			use Doctrine\ORM\EntityManagerInterface;
6			use Exception;
7			use HTMLPurifier;
8			use Psr\Log\LoggerInterface;
9			use SfCod\SocketIoBundle\Events\EventInterface;
10			use SfCod\SocketIoBundle\events\EventPolicyInterface;
11			use SfCod\SocketIoBundle\Events\EventPublisherInterface;
12			use SfCod\SocketIoBundle\events\EventRoomInterface;
13			use SfCod\SocketIoBundle\Events\EventSubscriberInterface;
14
15			/**
16			* Class Broadcast.
17			*
18			* @package SfCod\SocketIoBundle
19			*/
20			class Broadcast
21			{
22			/**
23			* @var array
24			*/
25			protected static $channels = [];
26			/**
27			* @var RedisDriver
28			*/
29			protected $redis;
30			/**
31			* @var LoggerInterface
32			*/
33			protected $logger;
34			/**
35			* @var EventManager
36			*/
37			protected $manager;
38			/**
39			* @var Process
40			*/
41			protected $process;
42			/**
43			* @var EntityManagerInterface
44			*/
45			protected $entityManager;
46
47			/**
48			* Broadcast constructor.
49			*/
50			public function __construct(RedisDriver $redis, EventManager $manager, LoggerInterface $logger, Process $process)
51			{
52			$this->redis = $redis;
53			$this->logger = $logger;
54			$this->manager = $manager;
55			$this->process = $process;
56			}
57
58			/**
59			* Subscribe to event from client.
60			*
61			* @return \Symfony\Component\Process\Process
62			*
63			* @throws Exception
64			*/
65			public function on(string $event, array $data)
66			{
67			// Clear data
68			array_walk_recursive($data, function (&$item, $key) {
			0 ignored issues – show Unused Code introduced 2018-02-21 21:28 UTC by Report Bug Copy Issue Report The parameter `$key` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
69			$item = (new HtmlPurifier())->purify($item);
70			});
71
72			$this->logger->info(json_encode(['type' => 'on', 'name' => $event, 'data' => $data]));
73
74			return $this->process->run($event, $data);
75			}
76
77			/**
78			* Run process.
79			*/
80			public function process(string $handler, array $data)
81			{
82			try {
83			/** @var EventInterface\|EventSubscriberInterface\|EventPolicyInterface $eventHandler */
84			$eventHandler = $this->manager->resolve($handler); //container->get(sprintf('socketio.%s', $handler));
85
86			if (false === $eventHandler instanceof EventInterface) {
87			throw new Exception('Event should implement EventInterface');
88			}
89
90			$eventHandler->setPayload($data);
91
92			if (false === $eventHandler instanceof EventSubscriberInterface) {
93			throw new Exception('Event should implement EventSubscriberInterface');
94			}
95
96			if (true === $eventHandler instanceof EventPolicyInterface && false === $eventHandler->can($data)) {
97			return;
98			}
99
100			if ($this->entityManager) {
101			$connection = $this->entityManager->getConnection();
102			$connection->close();
103			$connection->connect();
104			}
105
106			$this->logger->info(json_encode(['type' => 'process', 'name' => $handler, 'data' => $data]));
107
108			$eventHandler->handle();
109			} catch (Exception $e) {
110			$this->logger->error($e);
111			}
112			}
113
114			/**
115			* Emit event to client.
116			*
117			* @throws Exception
118			*/
119			public function emit(string $event, array $data)
120			{
121			$this->logger->info(json_encode(['type' => 'emit', 'name' => $event, 'data' => $data]));
122
123			try {
124			/** @var EventInterface\|EventPublisherInterface\|EventRoomInterface $eventHandler */
125			$eventHandler = $this->manager->resolve($event); // container->get(sprintf('socketio.%s', $event));
126
127			if (false === $eventHandler instanceof EventInterface) {
128			throw new Exception('Event should implement EventInterface');
129			}
130
131			$eventHandler->setPayload($data);
132
133			if (false === $eventHandler instanceof EventPublisherInterface) {
134			throw new Exception('Event should implement EventPublisherInterface');
135			}
136
137			$data = $eventHandler->fire();
138
139			if ($eventHandler instanceof EventRoomInterface) {
140			$data['room'] = $eventHandler->room();
141			}
142
143			$eventHandlerClass = get_class($eventHandler);
144			foreach ($eventHandlerClass::broadcastOn() as $channel) {
145			$this->publish($this->channelName($channel), [
146			'name' => $eventHandlerClass::name(),
147			'data' => $data,
148			]);
149			}
150			} catch (Exception $e) {
151			$this->logger->error($e);
152			}
153			}
154
155			/**
156			* Publish data to redis channel.
157			*/
158			protected function publish(string $channel, array $data)
159			{
160			$this->redis->getClient(true)->publish($channel, json_encode($data));
161			}
162
163			/**
164			* Prepare channel name.
165			*/
166			protected function channelName(string $name): string
167			{
168			return $name . getenv('SOCKET_IO_NSP');
169			}
170
171			/**
172			* Redis channels names.
173			*/
174			public function channels(): array
175			{
176			if (empty(self::$channels)) {
177			foreach ($this->manager->getList() as $eventHandlerClass) {
178			self::$channels = array_merge(self::$channels, $eventHandlerClass::broadcastOn());
179			}
180			self::$channels = array_unique(self::$channels);
181			self::$channels = array_map(function ($channel) {
182			return $this->channelName($channel);
183			}, self::$channels);
184			}
185
186			return self::$channels;
187			}
188
189			public function setEntityManager(EntityManagerInterface $entityManager)
190			{
191			$this->entityManager = $entityManager;
192			}
193			}
194

sfcod / socketio

Push — master ( 51c7de...741841 )

Broadcast::setEntityManager() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like