Shamaseen\Laravel\Ratchet\Receiver

Complexity

Total Complexity

15

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	onOpen()	0	8	1
A	onMessage()	0	36	5
A	onClose()	0	6	1
A	onError()	0	7	1
A	checkForRequiredInMessage()	0	10	4
A	cloneProperties()	0	6	2

<?php
/**
 * Created by PhpStorm.
 * User: shanmaseen
 * Date: 23/03/19
 * Time: 07:40 م
 */

namespace Shamaseen\Laravel\Ratchet;


use function Composer\Autoload\includeFile;
use Shamaseen\Laravel\Ratchet\Exceptions\WebSocketException;
use Shamaseen\Laravel\Ratchet\Facades\WsRoute;
use Shamaseen\Laravel\Ratchet\Objects\Clients\Client;
use Shamaseen\Laravel\Ratchet\Routes\Routes;
use Ratchet\ConnectionInterface;
use Ratchet\MessageComponentInterface;
use Shamaseen\Laravel\Ratchet\Traits\WebSocketMessagesManager;

/**
 * Class WebSocket
 * @package App\WebSockets
 */
class Receiver implements MessageComponentInterface
{
    use WebSocketMessagesManager;

    /**
     * @var Client[]
     */
    public $clients;
    private $routes;
    public $userAuthSocketMapper;


    /**
     * WebSocket constructor.
     */
    public function __construct()
    {
        $this->clients = [];
        $this->userAuthSocketMapper = [];
        WsRoute::mainRoutes();

        include base_path().'/routes/websocket.php';

        $this->routes = WsRoute::getRoutes();
    }

    /**
     * @param ConnectionInterface $conn
     */
    public function onOpen(ConnectionInterface $conn) {

        $this->clients[$conn->resourceId] = new Client();

Accessing resourceId on the interface Ratchet\ConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        $this->clients[$conn->resourceId]->conn = $conn;

Accessing resourceId on the interface Ratchet\ConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

//        $this->clients[$conn->resourceId]->resourceId = $conn->resourceId;

        echo "New connection! ({$conn->resourceId})\n";

Accessing resourceId on the interface Ratchet\ConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * @param ConnectionInterface $from
     * @param string $msg
     * @throws \Exception
     */
    public function onMessage(ConnectionInterface $from, $msg) {
        try

Expected 1 space(s) after TRY keyword; newline found

        {
            $msg = json_decode($msg);

            $this->checkForRequiredInMessage($msg,$from);

            \Session::setId($msg->session);

            \Session::start();

            if($this->routes[$msg->route]->auth && !\Auth::check())

Expected 1 space(s) after IF keyword; 0 found

                $this->error($msg,$from,'Unauthenticated.');
            else

Expected 1 space(s) after ELSE keyword; newline found

                $this->userAuthSocketMapper[\Auth::id()] = $from->resourceId;

Accessing resourceId on the interface Ratchet\ConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $class = $this->routes[$msg->route]->controller;
            $method = $this->routes[$msg->route]->method;
            $controller = new $class;

            $this->cloneProperties($this,$controller);

            $controller->conn = $from;

            if(!method_exists($controller,$method))

Expected 1 space(s) after IF keyword; 0 found

            {
                $this->error($msg,$from,'Method doesnt\'t exist !');
            }

            $controller->$method($msg);
        }
        catch (WebSocketException $exception)

Consider adding a comment why this CATCH block is empty.

        {

Blank line found at start of control structure

        }
    }

    /**
     * @param ConnectionInterface $conn
     */
    public function onClose(ConnectionInterface $conn) {
        // The connection is closed, remove it, as we can no longer send it messages
        unset($this->clients[$conn]);

        echo "Connection {$conn->resourceId} has disconnected\n";

Accessing resourceId on the interface Ratchet\ConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

    }

    /**
     * @param ConnectionInterface $conn
     * @param \Exception $e
     */
    public function onError(ConnectionInterface $conn, \Exception $e) {
        echo "An error has occurred: {$e->getMessage()}\n";

        $conn->close();
        echo 'end';
        die;
    }

    /**
     * @param $msg
     * @param $from
     * @throws WebSocketException
     */
    function checkForRequiredInMessage($msg,$from)

It is recommend to declare an explicit visibility for checkForRequiredInMessage.

Expected 1 space between comma and argument "$from"; 0 found

It is generally recommended to explicitly declare the visibility for methods.

    {
        if(!isset($msg->route) || !isset($msg->session))

Expected 1 space(s) after IF keyword; 0 found

        {
            $this->error($msg,$from,'You can\'t send a request without the route and the session id !');
        }

        if(!isset($this->routes[$msg->route]))

Expected 1 space(s) after IF keyword; 0 found

            $this->error($msg,$from,'No such route !');
    }

    /**
     * @param $clonedObject
     * @param $clone
     */
    function cloneProperties($clonedObject, $clone)

It is recommend to declare an explicit visibility for cloneProperties.

It is generally recommended to explicitly declare the visibility for methods.

    {
        foreach (get_object_vars($clonedObject) as $key => $value) {
            $clone->$key = $value;
        }
    }
}