140 lines
5.9 KiB
Python
140 lines
5.9 KiB
Python
import json
|
|
from channels.generic.websocket import AsyncJsonWebsocketConsumer
|
|
from channels.db import database_sync_to_async
|
|
from django.core.serializers.json import DjangoJSONEncoder
|
|
from .basic import execute_data_query
|
|
|
|
class DataConsumer(AsyncJsonWebsocketConsumer):
|
|
async def encode_json(self, content):
|
|
"""
|
|
Encode the given content as JSON, using Django's encoder
|
|
to handle dates, decimals, etc.
|
|
"""
|
|
return json.dumps(content, cls=DjangoJSONEncoder)
|
|
|
|
async def connect(self):
|
|
self.subscribed_groups = set()
|
|
self.subscription_params = {}
|
|
await self.accept()
|
|
|
|
async def disconnect(self, close_code):
|
|
for group_name in self.subscribed_groups:
|
|
await self.channel_layer.group_discard(group_name, self.channel_name)
|
|
|
|
async def receive_json(self, content):
|
|
action = content.get("action")
|
|
if action == "subscribe":
|
|
await self.handle_subscribe(content.get("payload", {}), content.get("request_id"))
|
|
|
|
async def handle_subscribe(self, payload, request_id):
|
|
model_name = payload.get("name")
|
|
params = payload.get("params", {})
|
|
|
|
if not model_name:
|
|
await self.send_json({"type": "error", "request_id": request_id, "message": "Model name is required."})
|
|
return
|
|
|
|
# Store subscription params for this client
|
|
self.subscription_params[model_name] = params
|
|
|
|
# Run the initial data query
|
|
data = await database_sync_to_async(execute_data_query)(model_name, params)
|
|
|
|
# Send the initial result back to the client
|
|
await self.send_json({
|
|
"type": "subscription_response",
|
|
"request_id": request_id,
|
|
"data": data
|
|
})
|
|
|
|
# Join the group using a lowercase model name to match the signal
|
|
group_name = f"model_{model_name.lower()}_updates"
|
|
if group_name not in self.subscribed_groups:
|
|
await self.channel_layer.group_add(group_name, self.channel_name)
|
|
self.subscribed_groups.add(group_name)
|
|
|
|
async def realtime_update(self, event):
|
|
# Bước gỡ lỗi cuối cùng: xác nhận phương thức này được gọi và bắt bất kỳ lỗi nào
|
|
print(f"--- CONSUMER: realtime_update invoked for event name: {event['payload']['name']} ---")
|
|
try:
|
|
# Move imports inside the method to prevent AppRegistryNotReady error on startup
|
|
from django.db.models import Q
|
|
from .views import get_serializer
|
|
|
|
payload = event["payload"]
|
|
change_type = payload.get("change_type")
|
|
record_id = payload["record"].get("id")
|
|
|
|
if not record_id or not change_type:
|
|
return
|
|
|
|
model_name_lower = payload["name"]
|
|
# Chuyển đổi snake_case (từ signal) thành PascalCase với dấu gạch dưới (được sử dụng trong subscription)
|
|
# Ví dụ: 'product_note' -> 'Product_Note'
|
|
model_name_pascal_case = '_'.join(word.capitalize() for word in model_name_lower.split('_'))
|
|
|
|
# 1. Lấy các tham số đăng ký của client này cho model cụ thể
|
|
client_params = self.subscription_params.get(model_name_pascal_case)
|
|
if not client_params:
|
|
return # Client này không đăng ký model này.
|
|
|
|
# 2. Xử lý sự kiện DELETION
|
|
if change_type == 'deleted':
|
|
await self.send_json({
|
|
"type": "realtime_update",
|
|
"payload": {
|
|
"name": model_name_lower,
|
|
"change_type": "deleted",
|
|
"record": {"id": record_id}
|
|
}
|
|
})
|
|
return
|
|
|
|
# 3. Xử lý sự kiện CREATION và UPDATE
|
|
Model, _ = get_serializer(model_name_lower)
|
|
if not Model:
|
|
return
|
|
|
|
# Xây dựng một đối tượng Q từ từ điển bộ lọc của client
|
|
filter_q = Q()
|
|
filter_dict = client_params.get('filter')
|
|
if isinstance(filter_dict, dict):
|
|
filter_q = Q(**filter_dict)
|
|
|
|
# Kiểm tra xem đối tượng có thực sự tồn tại với bộ lọc kết hợp không
|
|
record_exists = await database_sync_to_async(
|
|
Model.objects.filter(Q(pk=record_id) & filter_q).exists
|
|
)()
|
|
|
|
if record_exists:
|
|
# Nếu bản ghi khớp với bộ lọc, chạy lại truy vấn để lấy dữ liệu có định dạng đúng
|
|
single_record_params = client_params.copy()
|
|
single_record_params['filter'] = {'pk': record_id}
|
|
|
|
data = await database_sync_to_async(execute_data_query)(model_name_pascal_case, single_record_params)
|
|
|
|
if data and data.get('rows'):
|
|
payload_for_client = {
|
|
"name": model_name_lower,
|
|
"change_type": change_type,
|
|
"record": data['rows'][0]
|
|
}
|
|
await self.send_json({
|
|
"type": "realtime_update",
|
|
"payload": payload_for_client
|
|
})
|
|
else:
|
|
# Nếu bản ghi tồn tại nhưng không còn khớp với bộ lọc, coi như là một thao tác xóa đối với client này
|
|
await self.send_json({
|
|
"type": "realtime_update",
|
|
"payload": {
|
|
"name": model_name_lower,
|
|
"change_type": "deleted",
|
|
"record": {"id": record_id}
|
|
}
|
|
})
|
|
except Exception as e:
|
|
import traceback
|
|
print(f"!!!!!!!!!! EXCEPTION in realtime_update: {e} !!!!!!!!!!!")
|
|
traceback.print_exc()
|