Shamaseen\Laravel\Ratchet\Receiver

Complexity

Total Complexity

17

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	onOpen()	0	8	1
B	onMessage()	0	47	6
A	onClose()	0	6	1
A	onError()	0	8	1
A	checkForRequiredInMessage()	0	10	4
A	cloneProperties()	0	6	2
A	mainRoutes()	0	8	1

<?php
/** @noinspection PhpUndefinedFieldInspection */

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

namespace Shamaseen\Laravel\Ratchet;

use Illuminate\Validation\ValidationException;
use Shamaseen\Laravel\Ratchet\Exceptions\WebSocketException;
use Shamaseen\Laravel\Ratchet\Facades\WsRoute;
use Shamaseen\Laravel\Ratchet\Objects\Clients\Client;
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;
    public $rooms = [];

    /**
     * WebSocket constructor.
     */
    public function __construct()
    {
        $this->clients = [];
        /**
         * The key will be auth id, the value will be resourceId
         */
        $this->userAuthSocketMapper = [];

        $this->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();

            $route = $this->routes[$msg->route];
            if($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 = $route->controller;
            $method = $route->method;
            $controller = new $class;

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

            $controller->conn = $from;
            $controller->receiver = $this;
            $controller->request = $msg;
            $controller->route = $route;

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

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

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

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

Consider adding a comment why this CATCH block is empty.

        {

Blank line found at start of control structure

        }
        catch(ValidationException $exception)

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

The class Illuminate\Validation\ValidationException does not exist. Did you forget a USE statement, or did you not list all dependencies?

        {
            $this->sendToWebSocketUser($from,[
                'message'=>$exception->getMessage(),
                'errors'=> $exception->errors()
            ]);
        }
    }

    /**
     * @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->resourceId]);

        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) {

Avoid variables with short names like $e. Configured minimum length is 3.

        echo "An error has occurred: {$e->getMessage()}\n";
        echo "In {$e->getFile()} line {$e->getLine()}\n";

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

The method onError() contains an exit expression.

    }

    /**
     * @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;
        }
    }

    function mainRoutes()

It is recommend to declare an explicit visibility for mainRoutes.

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

    {
        WsRoute::make('initializeWebsocket','Shamaseen\Laravel\Ratchet\Controllers\InitializeController','index');
        WsRoute::make('room-enter','Shamaseen\Laravel\Ratchet\Controllers\RoomController','enterRoom');
        WsRoute::make('room-exit','Shamaseen\Laravel\Ratchet\Controllers\RoomController','exitRoom');
        WsRoute::make('send-to-user','Shamaseen\Laravel\Ratchet\Controllers\ChatController','sendMessageToUser');
        WsRoute::make('send-to-room','Shamaseen\Laravel\Ratchet\Controllers\ChatController','sendMessageToRoom');
    }
}