BeyondCode\LaravelWebSockets\Concerns\PresencelyChannelable

Complexity

Total Complexity

9

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getUsers()	0	4	1
A	subscribe()	0	35	1
A	unsubscribe()	0	26	2
A	toArray()	0	10	1
A	getChannelData()	0	10	1
A	getUserIds()	0	8	1
A	getHash()	0	10	2

<?php

namespace BeyondCode\LaravelWebSockets\Concerns;

use BeyondCode\LaravelWebSockets\WebSockets\Exceptions\InvalidSignature;
use Ratchet\ConnectionInterface;
use stdClass;

trait PresencelyChannelable
{
    /**
     * Data for the users connected to this channel.
     *
     * Note: If replication is enabled, this will only contain entries
     * for the users directly connected to this server instance. Requests
     * for data for all users in the channel should be routed through
     * ReplicationInterface.
     *
     * @var string[]
     */
    protected $users = [];

    /**
     * Get the members in the presence channel.
     *
     * @param  string  $appId
     * @return PromiseInterface
     */
    public function getUsers($appId)
    {
        return $this->replicator->channelMembers($appId, $this->channelName);

The property replicator does not exist. Did you maybe forget to declare it?

The property channelName does not exist. Did you maybe forget to declare it?

    }

    /**
     * Subscribe the connection to the channel.
     *
     * @param  ConnectionInterface  $connection
     * @param  stdClass  $payload
     * @return void
     * @throws InvalidSignature
     * @see     https://pusher.com/docs/pusher_protocol#presence-channel-events
     */
    public function subscribe(ConnectionInterface $connection, stdClass $payload)
    {
        $this->verifySignature($connection, $payload);

It seems like verifySignature() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->saveConnection($connection);

It seems like saveConnection() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $channelData = json_decode($payload->channel_data);
        $this->users[$connection->socketId] = $channelData;

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

        // Add the connection as a member of the channel
        $this->replicator->joinChannel(
            $connection->app->id,

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

            $this->channelName,
            $connection->socketId,

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

            json_encode($channelData)
        );

        // We need to pull the channel data from the replication backend,
        // otherwise we won't be sending the full details of the channel
        $this->replicator
            ->channelMembers($connection->app->id, $this->channelName)

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

            ->then(function ($users) use ($connection) {
                $connection->send(json_encode([
                    'event' => 'pusher_internal:subscription_succeeded',
                    'channel' => $this->channelName,
                    'data' => json_encode($this->getChannelData($users)),
                ]));
            });

        $this->broadcastToOthers($connection, (object) [

It seems like broadcastToOthers() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            'event' => 'pusher_internal:member_added',
            'channel' => $this->channelName,
            'data' => json_encode($channelData),
        ]);
    }

    /**
     * Unsubscribe the connection from the Presence channel.
     *
     * @param  ConnectionInterface  $connection
     * @return void
     */
    public function unsubscribe(ConnectionInterface $connection)
    {
        parent::unsubscribe($connection);

        if (! isset($this->users[$connection->socketId])) {

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

            return;
        }

        // Remove the connection as a member of the channel
        $this->replicator
            ->leaveChannel(
                $connection->app->id,

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

                $this->channelName,
                $connection->socketId

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

            );

        $this->broadcastToOthers($connection, (object) [

It seems like broadcastToOthers() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            'event' => 'pusher_internal:member_removed',
            'channel' => $this->channelName,
            'data' => json_encode([
                'user_id' => $this->users[$connection->socketId]->user_id,
            ]),
        ]);

        unset($this->users[$connection->socketId]);
    }

    /**
     * Get the Presence Channel to array.
     *
     * @param  string|null  $appId
     * @return PromiseInterface
     */
    public function toArray($appId = null)
    {
        return $this->replicator
            ->channelMembers($appId, $this->channelName)
            ->then(function ($users) {
                return array_merge(parent::toArray(), [
                    'user_count' => count($users),
                ]);
            });
    }

    /**
     * Get the Presence channel data.
     *
     * @param  array  $users
     * @return array
     */
    protected function getChannelData(array $users): array
    {
        return [
            'presence' => [
                'ids' => $this->getUserIds($users),
                'hash' => $this->getHash($users),
                'count' => count($users),
            ],
        ];
    }

    /**
     * Get the Presence Channel's users.
     *
     * @param  array  $users
     * @return array
     */
    protected function getUserIds(array $users): array
    {
        $userIds = array_map(function ($channelData) {
            return (string) $channelData->user_id;
        }, $users);

        return array_values($userIds);
    }

    /**
     * Compute the hash for the presence channel integrity.
     *
     * @param  array  $users
     * @return array
     */
    protected function getHash(array $users): array
    {
        $hash = [];

        foreach ($users as $socketId => $channelData) {
            $hash[$channelData->user_id] = $channelData->user_info ?? [];
        }

        return $hash;
    }
}