Django Websocket Websocket broadcast, peer-to-peer send messages code

django-admin startprobject ChannelsReady

# 
from  import ProtocolTypeRouter

application = ProtocolTypeRouter({
 # Temporarily empty
})

INSTALLED_APPS = [
 'channels'
]

ASGI_APPLICATION = ""

python  startapp chats

INSTALLED_APPS = [
 'chats',
 'channels'
]

from  import WebsocketConsumer
# In addition to the WebsocketConsumer, there is also the
# JsonWebsocketConsumer
# AsyncWebsocketConsumer
# AsyncJsonWebsocketConsumer
# WebsocketConsumer vs. JsonWebsocketConsumer is that there is an additional method that can automatically handle JSON.
# AsyncWebsocketConsumer and AsyncJsonWebsocketConsumer also have an additional JSON method
# AsyncWebsocketConsumer vs. WebsocketConsumer is the point.
# The name doesn't seem too hard to understand Async is just asynchronous with async / await
# Yes, there's nothing wrong with that, but the only thing that's different about them for us is probably the length of the name, the usage is exactly the same #
# What's great is that the base class is the same, and the methods of that base class are also Async asynchronous #

class ChatService(WebsocketConsumer):
 # When Websocket creates a connection
 def connect(self):
 pass
 
 # When the websocket receives a message
 def receive(self, text_data=None, bytes_data=None):
 pass
 
 # When a websocket disconnection occurs
 def disconnect(self, code):
 pass

from  import path
from  import ChatService
websocket_url = [
 path("ws/",ChatService)
]

from  import ProtocolTypeRouter,URLRouter
from  import websocket_url

application = ProtocolTypeRouter({
 "websocket":URLRouter(
 websocket_url
 )
})

<template>
 <div>
 <input type="text" v-model="message">
 <p><input type="button" @click="send" value="Send."></p>
 <p><input type="button" @click="close_socket" value="Close."></p>
 </div>
</template>


<script>
export default {
 name:'websocket1',
 data() {
 return {
  message:'',
  testsocket:''
 }
 },
 methods:{
 send(){
  
 // send send message
 // close Close the connection

  ()
   = (res) => {
  ("WS return results",);  
  }

 },
 close_socket(){
  ()
 }

 },
 mounted(){
  = new WebSocket("ws://127.0.0.1:8000/ws/") 


 // onopen Defines the function to use when opening.
 // onclose Defines the function to use when closing.
 // onmessage Defines the function to use when receiving data.
 //  = function(){
 // ("Starting socket connection")
 // },
 //  = function(){
 // ("The socket connection is closed.")
 // }
 }
}
</script>

socket_list = []

class ChatService(WebsocketConsumer):
 # When Websocket creates a connection
 def connect(self):
 ()
 socket_list.append(self)


 # When the websocket receives a message
 def receive(self, text_data=None, bytes_data=None):
 print(text_data) # Print received data
 for ws in socket_list: # Iterate over all WebsocketConsumer objects
 (text_data) # For each of theWebsocketConsumerObject sends data

<template>
 <div>
 <input type="text" v-model="message">
 <input type="text" v-model="user">

 <p><input type="button" @click="send" value="Send."></p>
 <p><input type="button" @click="close_socket" value="Close."></p>
 </div>
</template>


<script>
export default {
 name:'websocket1',
 data() {
 return {
  message:'',
  testsocket:'',
  user:''
 }
 },
 methods:{
 send(){
  
 // send send message
 // close Closes the connection
  var data1 = {"message":,"to_user":}
  
  ((data1))
   = (res) => {
  ("WS return results",);  
  }

 },
 close_socket(){
  ()
 },
 generate_uuid: function() {
  var d = new Date().getTime();
  if ( && typeof  === "function") {
  d += (); //use high-precision timer if available
  }
  var uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
  /[xy]/g,
  function(c) {
  var r = (d + () * 16) % 16 | 0;
  d = (d / 16);
  return (c == "x" ? r : (r & 0x3) | 0x8).toString(16);
  }
  );
  return uuid;
 },

 },
 mounted(){
 var username = this.generate_uuid();
 (username)
  = new WebSocket("ws://127.0.0.1:8000/ws/"+ username +"/") 
 ()

 	 = (res) => {
  ("WS return results",);  
  }
 	
 // onopen Defines the function to use when opening.
 // onclose Defines the function to use when closing.
 // onmessage Defines the function to use when receiving data.
 //  = function(){
 // ("Starting socket connection")
 // },
 //  = function(){
 // ("The socket connection is closed.")
 // }
 }
}
</script>

from  import WebsocketConsumer
user_dict ={}
list = []
import json
class ChatService(WebsocketConsumer):
 # When Websocket creates a connection
 def connect(self):
 ()
 username = ("url_route").get("kwargs").get("username")
 user_dict[username] =self
 print(user_dict)

 # (self)


 # When the websocket receives a message
 def receive(self, text_data=None, bytes_data=None):
 data = (text_data)
 print(data)
 to_user = ("to_user")
 message = ("message")

 ws = user_dict.get(to_user)
 print(to_user)
 print(message)
 print(ws)
 (text_data)


 # When a websocket disconnection occurs
 def disconnect(self, code):
 pass