服务端数据转发前端到API

meinvwudi

前端处理

local DataForwarder = {}
DataForwarder.__cname = "DataForwarder"
DataForwarder.NAME = DataForwarder.__cname

-- 数组包含检查工具函数
function table.contains(tbl, value)
    for _, v in ipairs(tbl) do
        if v == value then
            return true
        end
    end
    return false
end

-- 全局配置变量
local g_config = {
    backend_endpoint = "http://127.0.0.1:8000/api/",  -- 默认后端API基础地址
    registered_msg_configs = {},  -- 已注册的消息配置列表
    -- 配置将通过 init 方法从外部传入
}

--[[
    初始化配置
    从配置文件中读取后端端点名称和需要监听的消息配置
]]
function DataForwarder:init(config)
    -- 从配置文件中读取后端端点名称
    if config and config.backend_endpoint then
        g_config.backend_endpoint = config.backend_endpoint
    end
    
    -- 从配置文件中读取需要监听的消息配置并注册
    if config and config.msg_configs then
        for _, msgConfig in ipairs(config.msg_configs) do
            local msgID = msgConfig.id
            local msgType = msgConfig.type or "lua"  -- 默认是LUA类型
            self:registerMsgListener(msgID, msgType)
        end
    end
end


--[[
    注册消息监听器
    msgID: 消息ID
    msgType: 消息类型，"lua" 或 "txt" ，默认为 "lua"
]]
function DataForwarder:registerMsgListener(msgID, msgType)
    msgType = msgType or "lua"
    if g_config.registered_msg_configs[msgID] then
        return
    end
    
    local function networkCB(msgID, ...)
        -- 检查是否是sendluamsg格式的消息（参数数量和类型判断）
        -- sendluamsg格式: sendluamsg(actor, 1000, 1, 2, 3, "我是来自服务器的消息 By Lua")
        -- SENDCUSTMSG格式: SENDCUSTMSG 102 {"panel":"ActivityVip","action":"update","data":"data"}
        
        local params = {...}
        SL:Print("[DataForwarder] 收到消息ID " .. msgID .. " (" .. msgType .. ") 的原始参数: ")
        SL:dump(params)
        
        local msgData = {}
    
        -- 首先检查是否是sendluamsg格式（通常包含至少4个参数，且最后一个参数是字符串）
        if #params >= 4 then
            local lastParam = params[#params]
            if type(lastParam) == "string" and #lastParam > 0 then
                -- 检查字符串是否是JSON格式
                if string.sub(lastParam, 1, 1) == "{" or string.sub(lastParam, 1, 1) == "[" then
                    local success, result = pcall(SL.JsonDecode, SL, lastParam)
                    if success and result then
                        msgData = result
                        msgData.format = "json"
                        msgData.params = {}  -- 初始化参数数组
                        for j = 1, #params - 1 do
                            table.insert(msgData.params, params[j])
                        end
                        -- SL:Print("[DataForwarder] 解析到LUA格式JSON消息")
                    else
                        -- 不是JSON格式，可能是普通字符串消息
                        msgData = {
                            message = lastParam,
                            format = "sendluamsg",
                            params = {}
                        }
                        -- 收集其他参数
                        for j = 1, #params - 1 do
                            table.insert(msgData.params, params[j])
                        end
                        -- SL:Print("[DataForwarder] 解析到sendluamsg格式字符串消息")
                    end
                else
                    -- 最后一个参数不是JSON格式，是普通字符串
                    msgData = {
                        message = lastParam,
                        format = "sendluamsg",
                        params = {}
                    }
                    for j = 1, #params - 1 do
                        table.insert(msgData.params, params[j])
                    end
                    -- SL:Print("[DataForwarder] 解析到sendluamsg格式字符串消息")
                end
            else
                -- 最后一个参数不是字符串，可能是其他格式
                msgData = {
                    format = "unknown",
                    params = params
                }
                -- SL:Print("[DataForwarder] 消息格式未识别，包含所有原始参数")
            end
        else
            -- 参数数量较少，可能是TXT脚本格式
            if #params == 1 then
                -- 只有一个参数，检查是否是JSON格式
                local param = params[1]
                if type(param) == "string" and #param > 0 and (string.sub(param, 1, 1) == "{" or string.sub(param, 1, 1) == "[") then
                    local success, result = pcall(SL.JsonDecode, SL, param)
                    if success and result then
                        msgData = result
                        msgData.format = "txt_json"
                        msgData.msgid = msgID  -- 使用注册时的消息ID作为消息号
                        -- SL:Print("[DataForwarder] 解析到TXT格式JSON消息，消息号: " .. tostring(msgData.msgid))
                    else
                        -- 不是JSON格式，可能是其他类型
                        msgData = {
                            format = "txt_unknown",
                            params = params
                        }
                        -- SL:Print("[DataForwarder] TXT格式消息解析失败")
                    end
                elseif type(param) == "table" then
                    -- 如果是table类型，直接使用
                    msgData = param
                    msgData.format = "txt_json"
                    msgData.msgid = msgID  -- 使用注册时的消息ID作为消息号
                    -- SL:Print("[DataForwarder] 解析到TXT格式JSON消息（table类型），消息号: " .. tostring(msgData.msgid))
                else
                    msgData = {
                        format = "txt_unknown",
                        params = params
                    }
                    -- SL:Print("[DataForwarder] TXT格式消息未识别")
                end
            else
                -- 参数数量不符合预期格式
                msgData = {
                    format = "unknown",
                    params = params
                }
                -- SL:Print("[DataForwarder] 消息格式未识别，包含所有原始参数")
            end
        end
        
        -- 如果没有找到任何可解析的数据，创建一个包含所有参数的基础数据结构
        if not msgData or not next(msgData) then
            msgData = {
                format = "unknown",
                params = params
            }
            -- SL:Print("[DataForwarder] 消息格式未识别，包含所有原始参数")
        end
        
        -- SL:dump(msgData, "----------消息解析结果---", 3)
        -- 调用模块的处理函数
        self:handleMessage(msgID, msgData)
    end
    
    -- 根据消息类型选择注册方式
    if msgType == "txt" then
        SL:RegisterNetMsg(msgID, networkCB)
    else
        SL:RegisterLuaNetMsg(msgID, networkCB)
    end
    
    -- 将配置保存到注册信息中
    g_config.registered_msg_configs[msgID] = {type = msgType}
end

--[[
    处理服务端下发的消息
    msgID: 消息ID
    msgData: 解析后的消息数据
]]
function DataForwarder:handleMessage(msgID, msgData)
    SL:Print("[DataForwarder] 收到消息ID " .. msgID .. " 的数据: ")
    SL:dump(msgData)
    
    -- 验证消息数据的有效性
    if not msgData or type(msgData) ~= "table" then
        SL:Print("[DataForwarder] 收到无效的消息数据: " .. type(msgData))
        return
    end

    -- 处理HTTP请求方法
    local method
    if msgData.method then
        method = string.upper(tostring(msgData.method))
        
        
        -- 检查是否是标准HTTP方法
        local supportedMethods = {"GET", "POST", "PUT", "DELETE", "PATCH"}
        local isStandardMethod = false
        for _, supportedMethod in ipairs(supportedMethods) do
            if method == supportedMethod then
                isStandardMethod = true
                break
            end
        end
        
        -- 如果不是标准HTTP方法，使用默认的POST方法
        if not isStandardMethod then
            SL:Print("[DataForwarder] 未识别的HTTP方法: " .. method .. ", 使用默认的POST方法")
            method = "POST"
        else
            SL:Print("[DataForwarder] 使用标准HTTP方法: " .. method)
        end
    else
        -- 默认使用POST方法
        method = "POST"
        SL:Print("[DataForwarder] 使用默认HTTP方法: " .. method)
    end
    
    -- 转发数据到后端API
    self:forwardDataToBackend(msgData, msgID, method)
end

--[[
    转发数据到后端API
    data: 要转发的数据
    msgID: 消息ID
    method: HTTP请求方法，可选值: "GET", "POST", "PUT", "DELETE"等，默认"POST"
]]
function DataForwarder:forwardDataToBackend(data, msgID, method)
    -- 验证数据有效性
    if not data or type(data) ~= "table" then
        SL:Print("[DataForwarder] 无效的数据类型: " .. type(data))
        return
    end
    
    -- 设置默认请求方法
    local method = method or data.method or "POST"
    method = string.upper(method)
    
    -- 从服务端消息中获取token（支持多种可能的token字段名）
    local token = data.token or data.Token or (data.data and data.data.token) or (data.data and data.data.Token)
    
    local headers = {
        ["Content-Type"] = "application/json",
    }
    
    -- 对于非POST和GET方法，添加HTTP方法覆盖头部
    if method ~= "GET" and method ~= "POST" then
        headers["X-HTTP-Method-Override"] = method
    end
 
    local url = g_config.backend_endpoint
    local postDataString = nil
    
    -- 动态获取资源名称（如 bank、user 等）
    if data.resource then
        SL:Print("[DataForwarder] 使用资源名称: " .. data.resource)
        url = url .. data.resource .. "/"
    end
    
    local paramValue = nil
    if method == "GET" or method == "PUT" or method == "DELETE" or method == "PATCH" then
        -- 只通过 pk 字段自动识别路径参数，提高模块通用性
        if data.pk then
            paramValue = data.pk
            SL:Print("[DataForwarder] 使用 pk 字段作为路径参数: " .. paramValue)
            -- 直接使用参数值作为路径，符合 Django DRF ModelViewSet 格式
            local pathPattern = paramValue .. "/"
            url = url .. pathPattern
            SL:Print("[DataForwarder] 最终使用的URL: " .. url)
        end
    end
    
    -- 处理token传递
    if token then
        SL:Print("[DataForwarder] 使用Token进行身份验证: " .. token)
        if method == "GET" then
            -- GET请求无法设置请求头，将token作为查询参数
            local tokenParam = "token=" .. token
            if string.find(url, "?") then
                url = url .. "&" .. tokenParam
            else
                url = url .. "?" .. tokenParam
            end
            -- SL:Print("[DataForwarder] Token已添加到GET请求查询参数中")
        else
            -- 其他请求方法，设置Authorization头
            headers["Authorization"] = "Bearer " .. token
            -- SL:Print("[DataForwarder] Token已添加到请求头中")
        end
    else
        SL:Print("[DataForwarder] 消息中未包含Token，将不包含身份验证信息")
    end
    
    if method == "GET" then
        -- GET请求将参数添加到URL查询参数中
        -- 注意：当有 pk 字段时，已经是获取单个资源详情，不需要查询参数
        if not data.pk then
            local params = {}
            
            -- URL编码函数
            local function urlEncode(str)
                if type(str) ~= "string" then
                    return tostring(str)
                end
                -- 对特殊字符进行URL编码
                -- 匹配任何不是字母数字、空格、下划线、连字符、点号或波浪号的字符 。
                -- 在URL编码中，这些被排除的字符（ %w _-.~ ）
                -- 是URL中可以安全使用而不需要编码的字符（根据RFC 3986标准），其他所有字符都需要进行URL编码。
                local result = string.gsub(str, "([^%w _%-%.~])", function(c)
                    return string.format("%%%02X", string.byte(c))
                end)
                -- 将空格替换为+号
                result = string.gsub(result, " ", "+")
                return result
            end
            
            -- 处理普通查询参数
            for k, v in pairs(data) do
                -- 跳过已在URL路径中的 resource 参数，以及 method 字段
                if k ~= "resource" and k ~= "method" and k ~= "filter" and k ~= "ordering" and k ~= "page" and k ~= "pagesize" and k ~= "data" and k ~= "format" and k ~= "msgid" then
                    table.insert(params, tostring(k) .. "=" .. urlEncode(tostring(v)))
                end
            end
            
            -- 处理过滤参数（支持复杂查询）
            if data.filter and type(data.filter) == "table" then
                -- SL:Print("[DataForwarder] 解析到过滤参数: ")
                -- SL:dump(data.filter)
                for field, value in pairs(data.filter) do
                    table.insert(params, "filter[" .. tostring(field) .. "]=" .. tostring(value))
                end
            end
            
            -- 处理排序参数
            if data.ordering then
                -- SL:Print("[DataForwarder] 使用排序参数: " .. data.ordering)
                table.insert(params, "ordering=" .. data.ordering)
            end
            
            -- 处理分页参数
            if data.page then
                -- SL:Print("[DataForwarder] 使用分页参数: 第 " .. data.page .. " 页")
                table.insert(params, "page=" .. data.page)
            end
            
            if data.pagesize then
                -- SL:Print("[DataForwarder] 使用页面大小参数: " .. data.pagesize)
                table.insert(params, "pagesize=" .. data.pagesize)
            end
            
            -- 拼接查询参数到URL
            if #params > 0 then
                if string.find(url, "?") then
                    url = url .. "&" .. table.concat(params, "&")
                else
                    url = url .. "?" .. table.concat(params, "&")
                end
            end
        end
    else
        -- POST、PUT、DELETE等请求将数据放在请求体中
        -- 对于非GET请求，我们可以保留pk和resource字段在请求体中，以便后端处理
        -- 还可以选择是否保留 method 字段在请求体中
        postDataString = SL:JsonEncode(data)
        SL:Print("[DataForwarder] 转发数据到后端API: ", postDataString)
    end
    -- 定义回调函数
    local function httpsCB(success, response)
        -- 解析响应数据
        local responseData
        local returnData
        
        if success then
            -- SL:Print("[DataForwarder] 数据转发成功, 响应: ", response)
            responseData = response and SL:JsonDecode(response) or nil
            
            if responseData and responseData.success == true then
                SL:Print("[DataForwarder] 后端API操作成功: " .. (responseData.msg or "操作成功"))
                -- 如果有数据返回，打印数据信息
                if responseData.data then
                    SL:Print("[DataForwarder] 返回数据: ")
                    SL:dump(responseData.data)
                end
            else
                SL:Print("[DataForwarder] 后端API操作失败: " .. (responseData and responseData.msg or "未知错误"))
            end
        else
            SL:Print("[DataForwarder] 数据转发失败, 错误: ", response)
            -- 构造错误响应数据
            responseData = {
                success = false,
                msg = response or "网络请求失败"
            }
        end
        
        -- 确保返回数据存在且为table格式
        if not responseData then
            responseData = {
                success = false,
                msg = "响应解析失败"
            }
        end
        
        -- 将响应数据转换为JSON字符串
        returnData = SL:JsonEncode(responseData)
        
        -- 根据消息类型返回数据给服务端（无论成功或失败）
        local msgConfig = g_config.registered_msg_configs[msgID]
        if msgConfig then
            if msgConfig.type == "txt" then
                SL:SendNetMsg(msgID, 1, 2, 3, returnData)
                SL:Print("[DataForwarder] 使用TXT格式返回数据到服务端，消息ID: " .. msgID)
            else
                SL:SendLuaNetMsg(msgID, 1, 2, 3, returnData)
                SL:Print("[DataForwarder] 使用LUA格式返回数据到服务端，消息ID: " .. msgID)
            end
        else
            SL:Print("[DataForwarder] 未找到消息ID " .. msgID .. " 的配置，无法返回数据")
        end
    end
    
    SL:Print("[DataForwarder] 发送" .. method .. "请求到后端API, URL: " .. url)
    
    -- SL:ScheduleOnce(function ()
    -- 根据请求方法选择相应的HTTP请求函数
    if method == "GET" then
        SL:HTTPRequestGet(url, httpsCB)
    elseif method == "POST" then
        SL:HTTPRequestPost(url, httpsCB, postDataString, headers)
    elseif method == "PUT" then
        SL:HTTPRequestPost(url, httpsCB, postDataString, headers)
    elseif method == "DELETE" then
        SL:HTTPRequestPost(url, httpsCB, postDataString, headers)
    else
        -- 默认使用POST方法
        SL:HTTPRequestPost(url, httpsCB, postDataString, headers)
    end
    -- end, 0.0001)
end



return DataForwarder

meinvwudi

API:

# --- 标准库导入 ---
import json
import logging
from math import log
import time
from datetime import datetime

# --- 第三方库导入 ---
import django_filters
import demjson3 as demjson
from django.http import HttpResponse, QueryDict
from rest_framework.parsers import BaseParser, FormParser, MultiPartParser
from rest_framework.permissions import IsAuthenticated

from django_filters.rest_framework import DjangoFilterBackend
from rest_framework.filters import OrderingFilter
from rest_framework.pagination import PageNumberPagination

from rest_framework.viewsets import ModelViewSet
from django.http import Http404

# --- 本地应用导入 ---
from .authentication import FixedTokenAuthentication, MD5TokenAuthentication
from .models import PlayerLog, Server, Player, Bank
from .mixins import MessageMixin
from . import serializes


logger = logging.getLogger(__name__)

permission_classes = [IsAuthenticated]

class CustomPageNumberPagination(PageNumberPagination):
    page_size = 10
    page_size_query_param = 'pagesize'
    max_page_size = 100


class CustomResponseMixin:
    def custom_response(self, msg="成功", data=None, encoding='gbk', pagination_info=None, success=True):
        response_data = {
            "success": success,      # 操作状态标识
            "msg": msg,
            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "data": data
        }

        # 添加token验证成功标识到响应头
        token_value = getattr(self.request, 'validated_token', '')
        response_data['token'] = token_value

        # 添加分页信息
        if pagination_info:
            response_data["pagination"] = pagination_info

        json_str = json.dumps(response_data, ensure_ascii=False, separators=(',', ':'))
        encoded_bytes = json_str.encode(encoding)

        return HttpResponse(encoded_bytes, content_type=f'application/json; charset={encoding}')


class GBKJSONParser(BaseParser):
    media_type = 'application/json'

    def parse(self, stream, media_type=None, parser_context=None):
        try:
            raw_data = stream.read()
            logger.info(f"原始数据: {raw_data}")

            # 从请求头获取编码信息
            content_type = parser_context.get('request').content_type if parser_context else ''
            if 'charset=' in content_type:
                # 从 Content-Type 头部获取编码
                charset = content_type.split('charset=')[1].split(';')[0].strip()
                decoded_data = raw_data.decode(charset)
            else:
                # 默认尝试 UTF-8，失败后尝试 GBK
                try:
                    decoded_data = raw_data.decode('utf-8')
                except UnicodeDecodeError:
                    decoded_data = raw_data.decode('gbk')

            # 将其解析为类似表单的字典
            query_dict = QueryDict(decoded_data, encoding='utf-8')

            # 假设 JSON 数据在 'Param1' 键中
            if 'Param1' in query_dict:
                json_string = query_dict['Param1']
                return demjson.decode(json_string)
            else:
                # 如果没有 'Param1'，则尝试将整个数据作为 JSON 解析
                #
                return demjson.decode(decoded_data)

        except Exception as e:
            logger.error(f"解析请求数据时出错: {e}")
            raise


class ServerViewSet(MessageMixin, CustomResponseMixin, ModelViewSet):
    queryset = Server.objects.all()
    serializer_class = serializes.ServerSerializer
    parser_classes = [GBKJSONParser]

    CUSTOM_MESSAGES = {
        'create_success': '服务器信息创建成功',
        'update_success': '服务器信息更新成功',
        'not_found': '服务器信息不存在'
    }

    def create(self, request, *args, **kwargs):
        serveridx = request.data.get('serveridx')
        instance = None
        if serveridx:
            instance = Server.objects.filter(serveridx=serveridx).first()

        # 如果实例存在，则序列化器用于更新；否则，用于创建
        serializer = self.get_serializer(instance=instance, data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save()

        # 使用保存后的实例重新序列化以获取最新数据
        response_serializer = self.get_serializer(serializer.instance)

        return self.get_success_response(
            data=response_serializer.data,
            operation='update' if instance else 'create'
        )


class PlayerViewSet(MessageMixin, CustomResponseMixin, ModelViewSet):
    queryset = Player.objects.all()
    serializer_class = serializes.PlayerSerializer
    parser_classes = [GBKJSONParser]
    authentication_classes = [FixedTokenAuthentication]

    CUSTOM_MESSAGES = {
        'create_success': '玩家信息创建成功',
        'update_success': '玩家信息更新成功',
        'not_found': '玩家信息不存在'
    }

    def create(self, request, *args, **kwargs):
        userid = request.data.get('userid')
        instance = None
        if userid:
            instance = Player.objects.filter(userid=userid).first()

        serializer = self.get_serializer(instance=instance, data=request.data)
        serializer.is_valid(raise_exception=True)
        saved_instance = serializer.save()

        response_serializer = self.get_serializer(saved_instance)
        return self.get_success_response(
            data=response_serializer.data,
            operation='update' if instance else 'create'
        )


class PlayerLogViewSet(MessageMixin, CustomResponseMixin, ModelViewSet):
    queryset = PlayerLog.objects.all()
    serializer_class = serializes.PlayerLogSerializer
    parser_classes = [GBKJSONParser]
    authentication_classes = [FixedTokenAuthentication] # 应用新的认证类

    CUSTOM_MESSAGES = {
        'create_success': '玩家日志创建成功',
        'not_found': '玩家日志不存在'
    }

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)  # 验证失败会直接抛出异常，由全局处理器捕获
        instance = serializer.save()

        # 使用新创建的 instance 重新序列化以获取完整的输出数据
        response_serializer = self.get_serializer(instance)

        return self.get_success_response(
            data=response_serializer.data,
            operation='create'
        )


class BankFilter(django_filters.FilterSet):
    account = django_filters.CharFilter(field_name='account', lookup_expr='icontains', help_text='账号模糊查询')
    username = django_filters.CharFilter(field_name='username', lookup_expr='icontains', help_text='用户名模糊查询')

    class Meta:
        model = Bank
        fields = ['account', 'username']


class BankViewSet(MessageMixin, CustomResponseMixin, ModelViewSet):
    lookup_field = 'account'
    queryset = Bank.objects.all()
    serializer_class = serializes.BankSerializer
    parser_classes = [GBKJSONParser, FormParser, MultiPartParser]
    authentication_classes = [MD5TokenAuthentication]
    filter_backends = [DjangoFilterBackend, OrderingFilter]
    filterset_class = BankFilter
    ordering_fields = ['balance', 'create_time', 'update_time']
    ordering = ['-create_time']
    pagination_class = CustomPageNumberPagination

    CUSTOM_MESSAGES = {
        'create_success': '银行账号创建成功',
        'update_success': '银行记录更新成功',
        'delete_success': '银行记录删除成功',
        'retrieve_success': '查询成功',
        'list_success': '查询成功',
        'not_found': '指定的银行记录不存在',
        'already_exists': '账号已存在'
    }

    def _build_pagination_info(self):
        """构建分页信息"""
        return {
            "count": self.paginator.page.paginator.count,
            "total_pages": self.paginator.page.paginator.num_pages,
            "current_page": self.paginator.page.number,
            "has_next": self.paginator.page.has_next(),
            "has_previous": self.paginator.page.has_previous(),
            "page_size": self.paginator.page_size
        }

    def create(self, request, *args, **kwargs):
        """POST - 增加银行账号"""
        account = request.data.get('account')

        if Bank.objects.filter(account=account).exists():
            return self.custom_response(
                msg=self.get_message('already_exists'),
                data=None,
                encoding='utf-8'
            )

        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        instance = serializer.save()

        return self.get_success_response(
            data=serializer.data,
            operation='create'
        )

    def retrieve(self, request, *args, **kwargs):
        """GET - 查询余额"""
        try:
            instance = self.get_object()
            serializer = self.get_serializer(instance)
            return self.get_success_response(
                data=serializer.data,
                operation='retrieve'
            )
        except Http404:
            return self.get_not_found_response()

    def update(self, request, *args, **kwargs):
        """PUT - 修改银行记录（account字段为只读）"""
        try:
            instance = self.get_object()
            serializer = self.get_serializer(instance, data=request.data, partial=False)
            serializer.is_valid(raise_exception=True)
            updated_instance = serializer.save()

            return self.get_success_response(
                data=serializer.data,
                operation='update'
            )
        except Http404:
            return self.get_not_found_response()

    def destroy(self, request, *args, **kwargs):
        """DELETE - 删除银行记录"""
        try:
            instance = self.get_object()
            self.perform_destroy(instance)
            return self.get_success_response(
                data=None,
                operation='delete'
            )
        except Http404:
            return self.get_not_found_response()

    def list(self, request, *args, **kwargs):
        """GET - 列出所有银行账号"""
        queryset = self.filter_queryset(self.get_queryset())
        page = self.paginate_queryset(queryset)

        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.custom_response(
                data=serializer.data,
                msg=self.get_message('list_success'),
                encoding='utf-8',
                pagination_info=self._build_pagination_info()
            )

        serializer = self.get_serializer(queryset, many=True)
        return self.get_success_response(
            data=serializer.data,
            operation='list'
        )

meinvwudi

论证类:

import hashlib
import time
import threading

from django.conf import settings
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed

def get_client_ip(request):
    """获取请求的真实 IP 地址"""
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip


class FixedTokenAuthentication(BaseAuthentication):
    def authenticate(self, request):
        # 在 DEBUG 模式下，如果请求来自可浏览 API，则跳过验证
        if settings.DEBUG :
            return (None, None)
        # 1. 验证 IP 地址
        client_ip = get_client_ip(request)
        if client_ip not in settings.API_IP_WHITELIST:
            # 对于不在白名单的 IP，可以记录日志以备审计
            # logger.warning(f"来自非法 IP {client_ip} 的访问被拒绝。")
            raise AuthenticationFailed('IP地址不允许访问。')

        # 2. 验证固定 Token
        # 假设 Token 在请求体中
        request_token = request.data.get('TOKEN')

        if not request_token:
            raise AuthenticationFailed('请求必须包含 `TOKEN` 字段。')

        if request_token != settings.API_FIXED_TOKEN:
            raise AuthenticationFailed('无效的 TOKEN')


        # 认证成功
        return (None, None)


class MD5TokenAuthentication(BaseAuthentication):
    """
    基于 MD5 和时间戳的 Token 验证，用于验证来自 Lua 服务器的请求。
    Token 格式: userId.timestamp.signature
    签名逻辑: md5(f"{userId}.{timestamp}.{SECRET_KEY}")
    """

    # 添加类属性用于存储已使用的时间戳
    used_timestamps = {}
    lock = threading.Lock()

    def is_timestamp_used(self, unique_key):
        with self.lock:
            current_time = time.time()
            # 清理过期的记录
            expired_keys = [k for k, v in self.used_timestamps.items() if v <= current_time]
            for key in expired_keys:
                del self.used_timestamps[key]

            return unique_key in self.used_timestamps

    def mark_timestamp_used(self, unique_key, expire_time):
        with self.lock:
            self.used_timestamps[unique_key] = expire_time

    def authenticate(self, request):
        # 首先检查Header中的Authorization
        auth_header = request.headers.get('Authorization')

        if not auth_header:
            token = request.query_params.get('token') or request.GET.get('token')
            if not token:
                raise AuthenticationFailed('Token is required for authentication.')
        else:
            if not auth_header.startswith('Bearer '):
                raise AuthenticationFailed('Token is required for authentication.')
            token = auth_header.split(' ')[1]

        try:
            parts = token.split('.')
            if len(parts) != 4:  # 修改为4部分：userId.timestamp.nonce.signature
                raise ValueError("Token must have 4 parts separated by dots.")

            user_id, timestamp_str, nonce, received_signature = parts
            timestamp = int(timestamp_str)

            # 验证签名
            secret_key = getattr(settings, 'LUA_TOKEN_SECRET_KEY', 'slws20251224')
            data_to_sign = f"{user_id}.{timestamp}.{nonce}.{secret_key}"
            expected_signature = hashlib.md5(data_to_sign.encode('utf-8')).hexdigest()

            if received_signature.lower() != expected_signature.lower():
                raise AuthenticationFailed('Invalid token signature.')

            # 检查时间窗口（毫秒单位）
            current_time = time.time()
            time_diff = abs(current_time - timestamp)
            allowed_window = 5  # 5秒

            if time_diff > allowed_window:
                raise AuthenticationFailed('Token timestamp out of window')

            # 检查是否已处理过此时间戳
            unique_key = f"{user_id}:{timestamp}:{nonce}"  # 包含nonce的唯一标识
            if self.is_timestamp_used(unique_key):
                raise AuthenticationFailed('Token already used')

            # 标记时间戳已使用
            self.mark_timestamp_used(unique_key, timestamp + allowed_window)

            # 检查 token 是否过期
            expiration_seconds = getattr(settings, 'TOKEN_EXPIRATION_SECONDS', 3)
            if current_time > timestamp + expiration_seconds:
                raise AuthenticationFailed('Token has expired.')

        except (ValueError, IndexError):
            raise AuthenticationFailed('Invalid token format.')

        request.validated_token = token

        return None, None

meinvwudi

异常类

# 修改 data_api/exception_handler.py
import json
import logging
from datetime import datetime
from django.http import HttpResponse
from rest_framework.views import exception_handler as drf_exception_handler
from rest_framework.exceptions import AuthenticationFailed

logger = logging.getLogger('data_api')

def custom_exception_handler(exc, context):

    # 首先调用DRF默认的异常处理函数
    response = drf_exception_handler(exc, context)

    # 构建统一的响应数据结构（与CustomResponseMixin保持一致）
    custom_data = {
        'success': False,
        'msg': '服务器内部错误',
        'time': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        'data': {}
    }

    status_code = 500

    if response is not None:
        # 设置状态码
        status_code = response.status_code

        # 处理认证失败异常
        if isinstance(exc, AuthenticationFailed):
            # 如设置401前端回调无法获取JSON 数据
            status_code = 200
            custom_data['msg'] = str(exc.detail) if hasattr(exc, 'detail') else str(exc)
        # 如果是DRF处理过的异常
        elif isinstance(response.data, dict) and 'detail' in response.data:
            custom_data['msg'] = response.data['detail']
        elif isinstance(response.data, list):
            # 对于序列化器验证错误
            custom_data['msg'] = str(response.data[0]) if response.data else '验证错误'
        else:
            # 其他情况
            custom_data['msg'] = str(response.data)

        logger.error(f"API 异常: {custom_data['msg']}", exc_info=True)
    else:
        # 对于DRF未处理的异常
        logger.error(f'未捕获的服务器异常: {str(exc)}', exc_info=True)
        custom_data['msg'] = str(exc)

    # 将数据转换为 JSON 字符串并编码为 GBK
    json_str = json.dumps(custom_data, ensure_ascii=False, separators=(',', ':'))
    gbk_bytes = json_str.encode('gbk')


    # 创建 HTTP 响应并设置 GBK 编码
    return HttpResponse(
        gbk_bytes,
        content_type='application/json; charset=gbk',
        status=status_code
    )

meinvwudi

中间件,前端方法添加

# myproject/middleware.py
from django.http import HttpRequest


# game_data_platform/middleware.py
class HTTPMethodOverrideMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 检查 X-HTTP-Method-Override 头部
        method_override = request.META.get('HTTP_X_HTTP_METHOD_OVERRIDE')
        if method_override:
            # 重要：修改请求的 method 属性
            request.method = method_override.upper()

        response = self.get_response(request)
        return response

meinvwudi

服务端token生成



--- 使用MD5验证token的有效性
-- @param token string 从客户端接收到的token
-- @return boolean, string 验证结果 (is_valid)
function verify_token_md5(actor, token)
    local parts = {}
    for part in string.gmatch(token, "([^.]+)") do
        table.insert(parts, part)
    end

    -- 检查token格式是否为四段式
    if #parts ~= 4 then
        return false, "Token格式无效"
    end

    local userId, expirationTimeStr, nonce, received_signature = parts[1], parts[2], parts[3], parts[4]
    local expirationTime = tonumber(expirationTimeStr)

    -- 1. 检查token是否已过期
    if not expirationTime or os.time() > expirationTime then
        return false, "Token已过期"
    end

    -- 2. 重新计算签名进行比对
    -- 必须使用与生成时完全相同的拼接方式
    local data_to_sign = string.format("%s.%s.%s.%s", userId, expirationTimeStr, nonce, SECRET_KEY)
    local expected_signature = md5str(data_to_sign)

    if expected_signature ~= received_signature then
        return false, "Token签名无效"
    end

    -- 3. 验证通过
    return true
end

meinvwudi

token生成

--- 使用MD5生成一个有时效性的token
-- @param userId string 玩家的唯一ID
-- @return string 生成的token (格式: userId.expirationTime.signature)
function generate_token_md5(actor)
    local userId = getbaseinfo(actor, 2)
    -- sendmsg(actor,1,'{"Msg":"'..userId..'","FColor":255,"BColor":0,"Type":1,"Time":3,"SendName":"xxx","SendId":"123"}')

    -- 生成一个6位的随机数作为 Nonce
    local nonce = math.random(100000, 999999)

    -- 1. 计算过期时间戳
    local expirationTime =   os.time() + GLOBAL_CONFIG.EXPIRATION_SECONDS 

    -- 待签名数据现在包含 userId, expirationTime 和 nonce
    local data_to_sign = string.format("%s.%s.%s.%s", userId, expirationTime, nonce, GLOBAL_CONFIG.SECRET_KEY)

    -- 3. 计算MD5签名
    local signature = md5str(data_to_sign)

    -- 最终的token也包含nonce，格式为: userId.expirationTime.nonce.signature
    local token = string.format("%s.%s.%s.%s", userId, expirationTime, nonce, signature)
    
    local net_msg = string.format('{"method":"GET","resource":"bank","pk":"meinvwudi","token":"%s"}', token)
    sendluamsg(actor, 9801, 1, 2, 3, net_msg)

    return token
end

meinvwudi

QF测试代码

function handlerequest(actor, msgid, n1, n2, n3, sMsg)
    -- 首先，将整个JSON字符串转换为一个table
    local request_data = json2tblex(sMsg)
    if type(request_data) ~= "table" then
        sendmsg9(actor, "无效的请求数据格式", "#FF0000", 0)
        return
    end

    local token = request_data.token

    sendmsg9(actor, token, "#FFFFFF", 0)

    if verify_token_md5(actor, token) then
        -- token验证成功后，直接访问data字段，它已经是table格式了
        local data = request_data.data
        
        -- 现在您可以直接使用data这个table了
        if type(data) == "table" then
            release_print(data)
            sendmsg9(actor, "token验证成功，data内容：" .. (data.balance or '未知'), "#FFFFFF", 0)
        else
            sendmsg9(actor, "data字段不是一个有效的table", "#FF0000", 0)
        end

    else
        sendmsg9(actor, "token验证失败", "#FFFFFF", 0)
    end

    -- release_print(msgid, request_data.data)
end

meinvwudi

[@main]
\\
<傲世全套/@傲世全套>    <十二圣宠/@十二圣宠>  <POST/@POST> \\

<TOKEN生成/@TOKEN>  <创建一条/@创建一条>  <查询一条/@查询一条> <删除一条/@删除一条> <更新一条/@更新一条> <部份更新一条/@部份更新一条>  <查询多条/@查询多条> \ \
<降序/@降序> <升序/@升序> <上一页/@上一页> <下一页/@下一页> <第一页/@第一页> <最后一页/@最后一页>  <角色名查询/@角色名查询>\

[@角色名查询]
#IF 
#ACT 
generate_token_md5
MOV S$Web请求数据临时 {"method":"GET","resource":"bank","username":"虾","answer":"鹰","token":"<$LUARESULT>"}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-
MOV S$Web请求数据

[@第一页]
#ACT
generate_token_md5
MOV S$Web请求数据临时 {"method":"GET","resource":"bank","page":1,"pagesize":2}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-
MOV S$Web请求数据

[@下一页]
#ACT
generate_token_md5
MOV S$Web请求数据临时 {"method":"GET","resource":"bank","token":"<$LUARESULT>","page":2,"pagesize":2}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-




[@降序]
#ACT
generate_token_md5
MOV S$Web请求数据临时 {"method":"GET","resource":"bank","token":"<$LUARESULT>","ordering":"-balance"}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-
MOV S$Web请求数据

[@升序]
#ACT
generate_token_md5
MOV S$Web请求数据临时 {"method":"GET","resource":"bank","token":"<$LUARESULT>","ordering":"balance"}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-
MOV S$Web请求数据

[@创建一条]
#IF 
#ACT 
generate_token_md5
MOV S$Web请求数据临时 {"serveridx":"<$SERVERIDX>","token":"<$LUARESULT>","account":"<$USERACCOUNT>","username":"<$USERNAME>","action":"银行开户","pwd":"961020","question":"你在那上学","answer":"资溪","method":"POST","balance":188,"resource":"bank"}
; MOV S$Web请求数据临时 {"method":"DELETE","resource":"bank","pk":"<$USERID>","token":"<$LUARESULT>"}
sendmsg 6 -1-[<$LUARESULT>]--
; INC S$Web请求数据临时  <$STR(S$Web请求数据)>}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 -2-[<$LUARESULT>]--
MOV S$Web请求数据

[@查询一条]
#IF 
#ACT 
generate_token_md5
MOV S$Web请求数据临时 {"method":"GET","resource":"bank","pk":"<$USERACCOUNT>","token":"<$LUARESULT>"}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-
MOV S$Web请求数据

[@查询多条]
#IF 
#ACT 
generate_token_md5
MOV S$Web请求数据临时 {"method":"GET","resource":"bank","token":"<$LUARESULT>"}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-
MOV S$Web请求数据

[@删除一条]
#IF 
#ACT 
generate_token_md5
MOV S$Web请求数据临时 {"method":"DELETE","resource":"bank","pk":"<$USERACCOUNT>","token":"<$LUARESULT>"}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-


[@更新一条]
#IF 
#ACT 
generate_token_md5
MOV S$Web请求数据临时 {"account":"<$USERACCOUNT>","method":"PUT","resource":"bank","pk":"<$USERACCOUNT>","token":"<$LUARESULT>","balance":288}

SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-

[@部份更新一条]
#ACT
generate_token_md5
MOV S$Web请求数据临时 {"method":"PUT","resource":"bank","pk":"<$USERACCOUNT>","token":"<$LUARESULT>","balance":3288,"partcial":"True"}
SENDCUSTMSG 9800 <$STR(S$Web请求数据临时)>
sendmsg 6 --[<$LUARESULT>]--[<$STR(S$Web请求数据临时)>]-
MOV S$Web请求数据


[@TOKEN]
#IF 
#ACT 
generate_token_md5
sendmsg 6 66666666666
; SENDCUSTMSG 102 {"action":"generate_token_md5", "TOKEN":"<$LUARESULT>"}
; SENDCUSTMSG 102 {"action":"generate_token_md5","code":0,"msg":"ok","data":{"token":"<$LUARESULT>","expires_in":1800}}

[@POST]
#IF 
#ACT 
MOV S$日志URL http://192.168.2.38:8000/api/server/
generate_token_md5
SENDMSG 6 ------<$LUARESULT>---2----
MOV S$日志JSON {"servername":"<$ERVERNAME>","serveridx":"<$SERVERIDX>","kfday":<$KFDAY>,"hfcount":"<$HFCOUNT>","hfdays":"<$HFDAYS>","testservertime":"<$TESTSERVERTIME>","startservetime":"<$STARTSERVERTIME>","token":"<$LUARESULT>"} 
HTTPPOST <$STR(S$日志URL)> 1  <$STR(S$日志JSON)>

[@傲世全套]
#SAY 

<傲世全套/@傲世全套>    <十二圣宠/@十二圣宠>

[@傲世全套]
#ACT 
GIVE 傲世神剑
GIVE 傲世神甲
GIVE 傲世神盔
GIVE 傲世神链
GIVE 傲世神镯
GIVE 傲世神戒
GIVE 傲世神带
GIVE 傲世神靴
GIVE 傲世斗笠
GIVE 傲世のpk保护罩
GIVE 傲世兵符
GIVE 傲世宝石
GIVE 傲世印记Lv.Max

[@十二圣宠]
#ACT
GIVE 十二圣宠[鼠]
GIVE 十二圣宠[牛]
GIVE 十二圣宠[虎]
GIVE 十二圣宠[兔]
GIVE 十二圣宠[龙]
GIVE 十二圣宠[蛇]
GIVE 十二圣宠[马]
GIVE 十二圣宠[羊]
GIVE 十二圣宠[猴]
GIVE 十二圣宠[鸡]
GIVE 十二圣宠[狗]
GIVE 十二圣宠[猪]