added facade methods and individual client communication

Author: yubarajshrestha

README.md

@@ -69,6 +69,8 @@ BROADCAST_DRIVER=socketio
 **Example**
 
 ```python
+# broadcast to given channels
+
 from masonite.controllers import Controller
 from masonite.broadcasting import Broadcast
 
@@ -81,13 +83,54 @@ class YourController(Controller):
         broadcast.channel(["channel-name"], "event-name", broadcast_data)
 ```
 
+```python
+# broadcast to selected users/clients
+
+from masonite.controllers import Controller
+from masonite.broadcasting import Broadcast
+from socketio_driver.facades import Communicator
+
+class YourController(Controller):
+
+    def your_function(self, broadcast: Broadcast):
+        broadcast_data = {
+            "message": "Hello World"
+        }
+        clients = Communicator.clients()
+        ids = [client.socketID for client in clients]
+        broadcast.channel(ids, "event-name", broadcast_data)
+
+
+    def or_another_function(self, broadcast: Broadcast):
+        broadcast_data = {
+            "message": "Hello World"
+        }
+        clients = Communicator.clients()
+        broadcast.driver("socketio").user(clients[0]).send("event-name", broadcast_data)
+```
+
 **Helpers**
 
-List all connected clients:
-    
+Facade helpers...
+
 ```python
 from socketio_driver.facades import Communicator
+```
+
+```python
+# List all clients:  
+Communicator.clients()
+```
+```python
+# Get client by sessionID
+Communicator.client(id='client-session-id')
+```
+```python
+# Delete all clients
+Communicator.delete_all_clients()
+```
+```python
+# Delete client by SocketClient instance
+Communicator.delete(client)
 
-communicator.clients() # get list of connected clients
-communicator.client(id='client-id') # get client by id, id is basically a socket.io session id
 ```

src/socketio_driver/communicator.py

@@ -2,6 +2,7 @@
 import redis
 import msgpack
 from .models.socket_client import SocketClient
+from masonite.auth.Sign import Sign
 
 
 class Communicator:
@@ -117,18 +118,32 @@ def clients(self):
         return [self.client(key) for key in client_keys]
 
     def client(self, id):
-        client_data = self._client.hmget(id, "userID", "address", "sessionId", "connected")
+        client_data = self._client.hmget(
+            id, "userID", "address", "sessionID", "socketID", "connected"
+        )
         if client_data is None:
             return None
 
-        userID, address, sessionID, connected = client_data
+        userID, address, sessionID, socketID, connected = client_data
 
         userID = userID.decode("utf-8") if userID is not None else None
         address = address.decode("utf-8") if address is not None else None
         sessionID = sessionID.decode("utf-8") if sessionID is not None else None
+        socketID = socketID.decode("utf-8") if socketID is not None else None
         connected = connected.decode("utf-8") if connected is not None else False
-
-        return SocketClient(userID, address, sessionID, connected == "true")
-
-    def authenticate(self):
-        return True
+        return SocketClient(userID, address, sessionID, socketID, connected == "true")
+
+    def delete_all_clients(self):
+        keys = self._client.keys(pattern="mbroadcast:users:*")
+        for key in keys:
+            self._client.delete(key)
+
+    def delete(self, client: SocketClient):
+        if client is None:
+            return False
+        self._client.delete(f"mbroadcast:users:{client.sessionID}")
+
+    def authenticate(self, channel, socket_id, user_id):
+        string_to_sign = "%s:%s:%s" % (socket_id, channel, user_id)
+        auth = Sign().sign(string_to_sign)
+        return {"auth": auth}

src/socketio_driver/controllers/BroadcastController.py

@@ -0,0 +1,14 @@
+from masonite.controllers import Controller
+from masonite.broadcasting import Broadcast
+from masonite.request import Request
+from masonite.response import Response
+
+
+class BroadcastController(Controller):
+    def authorize(self, request: Request, broadcast: Broadcast, response: Response):
+        if not request.user():
+            return response.json({"message": "unauthorized"}, 204)
+
+        return broadcast.driver("socketio").authorize(
+            request.input("channel_name"), request.input("socket_id"), request.user().id
+        )

src/socketio_driver/drivers/socket_driver.py

@@ -1,7 +1,12 @@
+from ..models.socket_client import SocketClient
+
+
 class SocketDriver:
     def __init__(self, application) -> None:
         self.application = application
         self.connection = None
+        self.client: SocketClient = None
+        self.channels: list = []
 
     def set_options(self, options):
         self.options = options
@@ -16,9 +21,32 @@ def get_connection(self):
 
         return self.connection
 
+    def user(self, client: SocketClient):
+        self.client = client
+        return self
+
+    def channels(self, channels):
+        self.channels = channels
+        return self
+
+    def send(self, event, value):
+        connection = self.get_connection()
+        if self.client is not None:
+            self.channel(self.client.socketID, event, value)
+        elif len(self.channels) > 0:
+            for channel in self.channels:
+                self.channel(channel, event, value)
+        else:
+            connection.Emit(event, value)
+
+        self.client = None
+        self.channels = []
+
     def channel(self, channel, event, value):
         connection = self.get_connection()
         return connection.To(channel).Emit(event, value)
 
-    def authorize(self, channel, socket_id):
-        return self.get_connection().authenticate(channel=channel, socket_id=socket_id)
+    def authorize(self, channel, socket_id, user_id):
+        return self.get_connection().authenticate(
+            channel=channel, socket_id=socket_id, user_id=user_id
+        )

src/socketio_driver/facades/communicator.pyi

@@ -7,3 +7,9 @@ class Communicator:
     def client(id: str) -> SocketClient | None:
         """Returns a client by id."""
         ...
+    def delete(id: str) -> bool:
+        """Deletes a client by id."""
+        ...
+    def delete_all_clients() -> None:
+        """Deletes all clients."""
+        ...

src/socketio_driver/models/socket_client.py

@@ -6,4 +6,14 @@ class SocketClient:
     userID: str
     address: str
     sessionID: str
+    socketID: str
     connected: bool
+
+    def to_json(self):
+        return {
+            "userID": self.userID,
+            "address": self.address,
+            "sessionID": self.sessionID,
+            "socketID": self.socketID,
+            "connected": self.connected,
+        }

tests/integrations/app/controllers/WelcomeController.py

@@ -9,11 +9,19 @@ class WelcomeController(Controller):
     """WelcomeController Controller Class."""
 
     def show(self, view: View, broadcast: Broadcast):
-        users = Communicator.clients()
-        print(users)
         return view.render("welcome")
 
+    def users(self):
+        # Communicator.delete_all_clients()
+        users = Communicator.clients()
+
+        return {"users": [user.to_json() for user in users]}
+
     def broadcast(self, view: View, broadcast: Broadcast):
         broadcast_data = {"message": "Hello World"}
-        broadcast.channel(["default"], "welcome", broadcast_data)
+        users = Communicator.clients()
+        for user in users:
+            broadcast.driver("socketio").user(user).send("message", user.to_json())
+
+        broadcast.channel(["mbroadcast"], "message", broadcast_data)
         return {"hello": "world!"}

tests/integrations/routes/web.py

@@ -2,5 +2,6 @@
 
 ROUTES = [
     Route.get("/", "WelcomeController@show"),
+    Route.get("/users", "WelcomeController@users"),
     Route.get("/broadcast", "WelcomeController@broadcast"),
 ]

tests/integrations/templates/welcome.html

@@ -39,27 +39,26 @@
 
     const broadcast = new MasoniteBroadcastClient({
       url: 'http://localhost:3000/',
+      // broadcastUrl: 'http://localhost:8000/pusher/auth',
     })
 
-    broadcast.listen("welcome", (data) => {
-      console.log(data);
-    });
-
-    broadcast.listen("chat", (data) => {
-      console.log("Chat Data", data);
+    broadcast.onClientConnected(function (user) {
+      console.log(user);
     })
 
-    broadcast.listen("PublicEvent", (data) => {
-      console.log(data);
-    });
+    const subscription = broadcast.subscribe(channel)
 
-    broadcast.listen("PrivateEvent", (data) => {
+    subscription.listen("message", (data) => {
+      console.log(data);
+    }).listen("PublicEvent", (data) => {
+      console.log(data);
+    }).listen("PrivateEvent", (data) => {
       console.log(data);
     });
 
     const TestButton = document.getElementById("test");
     TestButton.addEventListener("click", () => {
-      broadcast.speak("welcome", {
+      subscription.emit("message", {
         message: "Hello World",
       });
     });