قنوات جانغو خطوة بخطوة

#business.py

import json
#pip install random_word
from random_word import RandomWords

class Domain:

    def __init__(self):
        self.R = RandomWords()

    def do(self):
        word = self.R.get_random_word()
        return json.dumps({"message": word})

#urls.py

from django.urls import path
from one.views import one

urlpatterns = [
    path('one/', one),
]

#views.py
from django.shortcuts import render

def one(request):
    return render(request, './templates/one.html', context={'one_text': "ASD"})

{% include 'base.html' %} {% block content%} {% load static %}
<div class="container">
  <p id="one">{{ one_text }}</p>
</div>

<script>
  var socket = new WebSocket("ws://localhost:8000/ws/any_url/");
  socket.onmessage = function (event) {
    var data = JSON.parse(event.data);
    console.log(data);
    document.querySelector("#one").innerText = data.message;
  };
</script>
{% endblock %}

#settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'channels',
    'one',
]

#asgi.py

import os

from django.core.asgi import get_asgi_application

from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack

from one.routing import ws_urlpatterns

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'examplechannels.settings')

application = ProtocolTypeRouter(
    {
        'http': get_asgi_application(),
        'websocket': AuthMiddlewareStack(URLRouter(ws_urlpatterns)),
    }
)

#settings.py

WSGI_APPLICATION = 'examplechannels.wsgi.application'

ASGI_APPLICATION = 'examplechannels.asgi.application'

import time
from channels.generic.websocket import WebsocketConsumer
from one.bussiness import Domain

class OneConsumer(WebsocketConsumer):
    
    def connect(self):
        self.accept()
        D = Domain()
        for i in range(100):
            data = D.do()
            self.send(data)
            time.sleep(2)

#routing.py

from django.urls import path
from one.consumers import OneConsumer

ws_urlpatterns = [
    path('ws/any_url/', OneConsumer.as_asgi())
]

{% include 'base.html' %} {% block content%} {% load static %}
<link rel="stylesheet" href="{% static 'css/one-style.css' %}?{% now 'U' %}" />

<div class="container">
  <div class="chart">
    <canvas id="iot-chart" width="800" height="400"></canvas>
  </div>
</div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.4.0/Chart.min.js"></script>
<script src="{% static 'js/two.js' %}"></script>
{% endblock %}

#business.py

import json
import random

class DomainTwo:

    def do(self):
        value = random.randint(0,100)
        return json.dumps({'data': value})

#routing.py

from django.urls import path
from two.consumers import TwoConsumer

ws_urlpatterns = [
    path('ws/two_url/', TwoConsumer.as_asgi())
]

#urls.py

from django.urls import path
from two.views import two

urlpatterns = [
    path('two/', two),
]

#views.py

from django.shortcuts import render

def two(request):
    return render(request, './templates/two.html')

#consumers.py

import time
from channels.generic.websocket import AsyncWebsocketConsumer
from asyncio import sleep
from two.business import DomainTwo

class TwoConsumer(AsyncWebsocketConsumer):
    
    async def connect(self):
        await self.accept()
        D = DomainTwo()
        for i in range(100):
            data = D.do()
            await self.send(data)
            await sleep(2)

pip install channels-redis

#settings.py

CHANNEL_LAYERS = {
    'default' : {
        'BACKEND' : 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
            'hosts':[('127.0.0.1', 6739)]
        }
    }
}

System check identified no issues (0 silenced).
November 28, 2022 - 21:07:30
Django version 4.0, using settings 'examplechannels.settings'
Starting ASGI/Channels version 3.0.4 development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
HTTP GET /two/ 200 [0.03, 127.0.0.1:51340]
HTTP GET /static/css/one-style.css?1669669655 200 [0.01, 127.0.0.1:51340]
HTTP GET /static/js/two.js 200 [0.02, 127.0.0.1:51341]
WebSocket HANDSHAKING /ws/two_url/ [127.0.0.1:51343]
WebSocket CONNECT /ws/two_url/ [127.0.0.1:51343]

#urls.py

from django.urls import path
from threechat.views import chat, room

urlpatterns = [
    path('chat/', chat, name='chat_index'),
    path('chat/<str:room_name>/', room, name="chat_room"),
]

#views.py

from django.shortcuts import render

# Create your views here.
def chat(request):
    return render(request, './templates/threechat.html', context={})

def room(request, room_name):
    return render(request, './templates/threeroom.html', context={'room_name': room_name})

#routing.py

from django.urls import re_path
from threechat.consumers import RoomConsumer

ws_urlpatterns = [
    re_path(r'ws/chat/(?P<room_name>\w+)/$', RoomConsumer.as_asgi())
]

{% include 'base.html' %} {% load static %} {% block content%}
<link rel="stylesheet" href="{% static 'css/chat-style.css' %}?{% now 'U' %}" />
<div>
  <div class="container">
    <div class="row d-flex justify-content-center">
      <div class="col-6">
        <form>
          <div class="form-group">
            <label for="textarea1" class="h4 pt-5"
              >Chatroom - {{room_name}}</label
            >
            <textarea class="form-control" id="chat-text" rows="10"></textarea>
          </div>
          <div class="form-group">
            <input class="form-control" id="input" type="text" /><br />
          </div>
          <input
            class="btn btn-success btn-lg btn-block"
            id="submit"
            type="button"
            value="Send"
          />
        </form>
      </div>
    </div>
  </div>
</div>
{{room_name|json_script:"room-name"}}
{{request.user.username|json_script:"username"}}
<script>
  const userName = JSON.parse(document.getElementById("username").textContent);
  const roomName = JSON.parse(document.getElementById("room-name").textContent);
  document.querySelector("#submit").onclick = function (e) {
    const msgInput = document.querySelector("#input");
    const message = msgInput.value;
    chatSocket.send(JSON.stringify({ message: message, username: userName }));
    msgInput.value = "";
  };

  const chatSocket = new WebSocket(
    "ws://" + window.location.host + "/ws/chat/" + roomName + "/"
  );

  chatSocket.onmessage = function (event) {
    const data = JSON.parse(event.data);
    document.querySelector("#chat-text").value +=
      data.username + ": " + data.message + "\n";
  };
</script>
<script
  src="https://code.jquery.com/jquery-3.5.1.slim.min.js"
  integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj"
  crossorigin="anonymous"
></script>
<script
  src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js"
  integrity="sha384-9/reFTGAW83EW2RDu2S0VKaIzap3H66lZH81PoYlFhbGU+6BZp6G7niu735Sk7lN"
  crossorigin="anonymous"
></script>
<script
  src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js"
  integrity="sha384-B4gt1jrGC7Jh4AgTPSdUtOBvfO8shuf57BaghqFfPlYxofvL8/KUEfYiJOMMV+rV"
  crossorigin="anonymous"
></script>
{% endblock %}

#consumers.py

import json
from channels.generic.websocket import AsyncWebsocketConsumer

class RoomConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        self.room_name = self.scope['url_route']['kwargs']['room_name']
        self.room_group_name = 'chat_%s' % self.room_name

        await self.channel_layer.group_add(self.room_group_name, self.channel_name)

        await self.accept()

    async def disconnect(self, code):
        await self.channel_layer.group_discard(self.room_group_name, self.channel_name)

    async def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']
        username = text_data_json['username']

        await self.channel_layer.group_send(self.room_group_name, {'type':'chatroom_message','message':message, 'username':username})
    
    async def chatroom_message(self, event):
        message = event['message']
        username = event['username']
        await self.send(text_data=json.dumps({'message':message, 'username':username}))

{'type': 'websocket', 'path': '/ws/chat/asd/', 'raw_path': b'/ws/chat/asd/', 
'headers': [(b'host', b'127.0.0.1:8000'), (b'pragma', b'no-cache'), 
            (b'accept', b'*/*'), (b'sec-websocket-key', 
             (b'DtE1JGLUF0e8X2DLld6l6g=='), (b'sec-websocket-version', b'13'), 
             (b'accept-language', b'en-US,en;q=0.9'), 
(b'sec-websocket-extensions', b'permessage-deflate'), 
(b'cache-control', b'no-cache'), (b'accept-encoding', b'gzip, deflate'), 
(b'origin', b'http://127.0.0.1:8000'), 
(b'user-agent', 
b'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15'), (b'connection', b'Upgrade'), 
(b'upgrade', b'websocket'), (b'cookie', b'csrftoken=qNTynYDGkiIdYsAZEHlqZwuqv98D3EBMZopHw87eOENNOavGczQyX286og7GFCHQ; sessionid=nwxc4zfv1lnq515wdqhxzcqfzln7bev6')], 
'query_string': b'', 
'client': ['127.0.0.1', 49417], 
'server': ['127.0.0.1', 8000], 
'subprotocols': [], 'asgi': {'version': '3.0'}, 
'cookies': {'csrftoken': 'qNTynYDGkiIdYsAZEHlqZwuqv98D3EBMZopHw87eOENNOavGczQyX286og7GFCHQ', 'sessionid': 'nwxc4zfv1lnq515wdqhxzcqfzln7bev6'}, 
'session': <django.utils.functional.LazyObject object at 0x7f9a68617d00>, 
'user': <channels.auth.UserLazyObject object at 0x7f9a483da370>, 
'path_remaining': '', 'url_route': {'args': (), 
'kwargs': {'room_name': 'asd'}}}

text_data:  {"message":"adsasd","username":"admin"}

chatSocket.send(JSON.stringify({ message: message, username: userName }));