Djangochannels在模型更改时发送消息

Question

我正在使用django频道在后端组织我的WebSocket。 现在一切都正常工作，除了消息发送到前端时，数据库中的信息被更改。存在要更改模型的http端点。你知道吗

这是我的websocket消费者

import asyncio
from asgiref.sync import async_to_sync, sync_to_async
from channels.generic.websocket import AsyncJsonWebsocketConsumer
from rest_framework.response import Response
from rest_framework import status
from channels.db import database_sync_to_async

# models and serializers

from billing.models import Billing
from billing.serializers import BillingSerializer
from customers.models import Customer
from customers.serializers import CustomersSerializer
from shipping.models import Shipping
from shipping.serializers import ShippingSerializer

from .models import Order
from .serializers import OrdersSerializer
from .views import OrdersViewSet

from .exceptions import ClientError
from .utils import get_orders_or_error, get_orders_or_warning


class OrdersConsumer(AsyncJsonWebsocketConsumer):

    async def connect(self):

        orders = await get_orders_or_warning()

        if 'user' in self.scope:
            await self.close()
        else:
            await self.accept()

        self.orders = set(orders)
        # await self.create_order(content)

    async def receive_json(self, content):
        command = content.get('command', None)

        orders = await get_orders_or_warning()
        # print(list(self.orders))
        # print(set(orders))

        try:
            if command == "join":
                await self.join_room(JWT_Token=content['token'])
            elif command == "leave":
                await self.leave_room()
            elif command == "send":
                await self.send_room(content['message'])
        except ClientError as e:
            await self.send_json({"error": e.code})

    async def disconnect(self, code):
        for room_id in list(self.rooms):
            try:
                self.send_json({
                    'type': 'CLOSE',
                    'message': "Socket closed"
                })
                await self.leave_room(content['token'])
            except ClientError:
                pass

    async def join_room(self, JWT_Token):
        orders = await get_orders_or_warning()
        serializer = OrdersSerializer(orders, many=True)
        # print('serializer', serializer)

        if self.orders != set(orders):
            await self.send_json(
                {
                    'type': 'orders',
                    'data': json.dumps(serializer.data),
                },
            )

        await self.send_json(
            {
                'type': 'orders',
                'data': json.dumps(serializer.data),
            },
        )

    async def leave_room(self, JWT_Token):

        await self.channel_layer.group_send(
            orders.group_name,
            {
                'type': 'orders.leave',
                'JWT_Token': JWT_Token
            }
        )

        self.rooms.discard()

        await self.channel_layer.group_discard(
            orders.group_name,
            self.channel_name
        )

        await self.send_json({
            "leave": str(room_id),
        })

    async def send_room(self, message):
        if room_id not in self.rooms:
            raise ClientError("ROOM_ACCESS_DENIED")

        orders = await get_orders_or_warning()
        serializer = OrdersSerializer(orders, many=True)

        await self.send_json(
            {
                'type': 'orders.give',
                'data': json.dumps(serializer.data)
            }
        )
        await self.send(text_data=json.dumps({
            'message': message
        }))

    async def orders_leave(self, event):
        await self.send_json(
            {
                'type': 'LEAVE',
                'room': event["room_id"],
                'username': event["username"]
            }
        )

这是我的路由文件

application = ProtocolTypeRouter({
    'websocket': (
            URLRouter([
                url('orders/', OrdersConsumer),
            ])
    )
})

当发生一些变化时，我想用前端获取所有数据。这可以用当前的消费者来完成吗？如果是，怎么做？我已经看了太多的信息来源，我想现在我有点困惑，我怎么才能真正做到这一点。你知道吗

如果可能的话，我不想重写结构。如果你能解释一下为什么我要用你说的方式写，我将非常感激

Answer 1

您可以使用信号来监视更改，并使用how to interact with the consumer from the outside上文档中定义的方法向使用者发送消息