Merge branch 'main' of https://github.com/qsc20001102/astrbot_plugin_jx3api

api_config.json

@@ -7,29 +7,5 @@
             "server": "眉间雪",  
             "num": 0  
         }
-    },
-    "jx3_shaohua":{
-        "url":"https://www.jx3api.com/data/saohua/random",
-        "method":"GET",
-        "description":"获取剑网三骚话",
-        "params":{
-            "name": "万花" 
-        }
-    },
-    "jx3_jigai":{
-        "url":"https://www.jx3api.com/data/skills/records",
-        "method":"GET",
-        "description":"获取剑网三技能记录",
-        "params":{
-        }
-    },
-    "aijx3_shapan":{
-        "url":"https://www.jianxiachaguan.cn/api2/aijx3-jxcg/game/get-sand-table-img",
-        "method":"POST",
-        "description":"获取剑网三沙盘状态",
-        "params":{
-            "serverName": "眉间雪"
     }
 }
-
-}

core/api_data.py

@@ -20,14 +20,14 @@ class APIClient:
         self.base_timeout = base_timeout
         self.ssl_verify = ssl_verify
     
-    async def _make_request(self, method, url, params_data=None):
+    async def _make_request(self, method, url, **kwargs):
         """
-        内部请求方法，统一处理请求逻辑
+        内部请求方法，处理通用请求逻辑
         
         Args:
             method: 请求方法 ('GET', 'POST')
             url: 请求URL
-            params_data: 统一的参数字典，如 {"name": "万花"}
+            **kwargs: 其他请求参数
         
         Returns:
             成功时返回解析后的数据，失败返回None
@@ -35,75 +35,22 @@ class APIClient:
         timeout = ClientTimeout(total=self.base_timeout)
         
         try:
-            # 添加请求日志
-            logger.debug(f"发起 {method} 请求: {url}")
-            logger.debug(f"参数数据: {params_data}")
-            
             async with aiohttp.ClientSession(timeout=timeout) as session:
-                if method.upper() == 'GET':
+                async with session.request(method, url, ssl=self.ssl_verify, **kwargs) as response:
-                    # GET请求：参数作为查询字符串
-                    async with session.get(
-                        url, 
-                        params=params_data,
-                        ssl=self.ssl_verify
-                    ) as response:
-                        return await self._handle_response(response)
-                
-                elif method.upper() == 'POST':
-                    # POST请求：参数作为JSON数据
-                    headers = {'Content-Type': 'application/json'}
-                    async with session.post(
-                        url,
-                        json=params_data,  # 使用json参数而不是data
-                        headers=headers,
-                        ssl=self.ssl_verify
-                    ) as response:
-                        return await self._handle_response(response)
-                
-                else:
-                    logger.error(f"不支持的HTTP方法: {method}")
-                    return None
-                    
-        except aiohttp.ClientError as e:
-            logger.error(f"请求出错: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"未知错误: {e}")
-            return None
-    
-    async def _handle_response(self, response):
-        """
-        处理HTTP响应
-        
-        Args:
-            response: aiohttp响应对象
-            
-        Returns:
-            解析后的数据或None
-        """
-        try:
-            # 添加响应日志
-            logger.debug(f"响应状态: {response.status}")
-            
                     response.raise_for_status()
                     data = await response.json()
                     
-            logger.debug(f"响应数据: {data}")
-            
                     # 检查API响应状态
                     return self._check_response_data(data)
                     
         except aiohttp.ClientError as e:
-            logger.error(f"HTTP错误: {e}")
+            logger.error(f"请求出错: {e}")
             return None
         except json.JSONDecodeError as e:
             logger.error(f"JSON解析错误: {e}")
-            # 尝试读取原始文本内容
+            return None
-            try:
+        except Exception as e:
-                text_content = await response.text()
+            logger.error(f"未知错误: {e}")
-                logger.error(f"原始响应内容: {text_content}")
-            except:
-                pass
             return None
     
     def _check_response_data(self, data):
@@ -116,16 +63,8 @@ class APIClient:
         Returns:
             检查通过返回数据，否则返回None
         """
-        # 如果数据是字符串，尝试解析为JSON
-        if isinstance(data, str):
-            try:
-                data = json.loads(data)
-            except json.JSONDecodeError:
-                logger.error("响应数据是无效的JSON字符串")
-                return None
-        
         # 检查是否有code字段
-        if data and 'code' in data:
+        if 'code' in data:
             # 有code字段时，检查是否成功
             if data.get('code') not in [200, "0", 0]:
                 logger.error(f"API返回错误:{data.get('code', '未知状态')} {data.get('msg', '未知错误')}")
@@ -138,19 +77,19 @@ class APIClient:
         
         return data
     
-    async def post(self, api_url, params_data=None, outdata=None):
+    async def post(self, api_url, json_data=None, outdata=None):
         """
         POST请求方法
         
         Args:
             api_url: API地址
-            params_data: 参数字典，如 {"name": "万花"}
+            json_data: POST请求的JSON数据
             outdata: 返回数据中要提取的字段
         
         Returns:
             成功时返回outdata字段的数据，失败返回None
         """
-        data = await self._make_request('POST', api_url, params_data)
+        data = await self._make_request('POST', api_url, json=json_data)
         
         if data is None:
             return None
@@ -159,19 +98,42 @@ class APIClient:
             return data
         return data.get(outdata, {})
     
-    async def get(self, api_url, params_data=None, outdata=None):
+    async def get(self, api_url, params=None, outdata=None):
         """
         GET请求方法
         
         Args:
             api_url: API地址
-            params_data: 参数字典，如 {"name": "万花"}
+            params: 其他查询参数
             outdata: 返回数据中要提取的字段
         
         Returns:
             成功时返回outdata字段的数据，失败返回None
         """
-        data = await self._make_request('GET', api_url, params_data)
+        data = await self._make_request('GET', api_url, params=params)
+        
+        if data is None:
+            return None
+            
+        if outdata is None or outdata == "":
+            return data
+        return data.get(outdata, {})
+
+    async def request(self, api_config, outdata=None):
+        """
+        通用请求方法，根据api_config中的method选择GET或POST
+        
+        Args:
+            api_config: 包含url, method, params/json等信息的字典
+            outdata: 返回数据中要提取的字段
+        
+        Returns:
+            成功时返回outdata字段的数据，失败返回None
+        """
+        if 'url' not in api_config or 'method' not in api_config:
+            logger.error("api_config必须包含url和method字段")
+            return None
+        data = await self._make_request(api_config['method'], api_config['url'], params=api_config['params'])
         
         if data is None:
             return None
@@ -181,13 +143,19 @@ class APIClient:
         return data.get(outdata, {})
 
 
-# 保持原有函数接口的兼容性
+
-async def api_data_post(api_url, params_data=None, outdata=None):
+
+
+
+
+
+# 保持原有函数接口的兼容性（可选）
+async def api_data_post(api_url, json_data=None, outdata=None):
     """兼容原有函数的POST请求"""
     client = APIClient()
-    return await client.post(api_url, params_data, outdata)
+    return await client.post(api_url, json_data, outdata)
 
-async def api_data_get(api_url, params_data=None, outdata=None):
+async def api_data_get(api_url, params=None, outdata=None):
     """兼容原有函数的GET请求"""
     client = APIClient()
-    return await client.get(api_url, params_data, outdata)
+    return await client.get(api_url, params, outdata)

core/jx3_Function.py

@@ -1,121 +0,0 @@
-from astrbot.api import logger
-from astrbot.api.event import filter, AstrMessageEvent, MessageEventResult
-
-from .api_data import APIClient
-
-
-class JX3Function:
-    def __init__(self, api_config):
-        self.__api = APIClient()
-        self.__api_config = api_config
-
-    async def richang(self,server: str = "眉间雪",num: int = 0):
-        return_data = {
-            "code": 0,
-            "msg": "功能函数未执行",
-            "data": {}
-        }
-        #在配置文件中获取接口配置
-        api_config = self.__api_config["jx3_richang"]
-        #更新参数
-        api_config["params"]["server"] = server
-        api_config["params"]["num"] = num
-        # 获取数据
-        data = await self.__api.get(api_config["url"],api_config["params"],"data")        
-        if not data:
-            return_data["msg"] = "获取接口信息失败"
-            return  return_data      
-        # 处理返回数据
-        try:
-            result_msg = f"{server}-{data.get('date')}-星期{data.get('week')}\n"
-            result_msg += f"大战：{data.get('war')}\n"
-            result_msg += f"战场：{data.get('battle')}\n"
-            result_msg += f"阵营：{data.get('orecar')}\n"
-            result_msg += f"宗门：{data.get('school')}\n"
-            result_msg += f"驰援：{data.get('rescue')}\n"
-            result_msg += f"画像：{data.get('draw')}\n"
-            result_msg += f"宠物福缘：\n{data.get('luck')}\n"
-            result_msg += f"家园声望：\n{data.get('card')}\n"
-            result_msg += f"武林通鉴：\n{data.get('team')}\n"
-            return_data["data"] = result_msg
-            return_data["code"] = 200       
-        except Exception as e:
-            logger.error(f"处理数据时出错: {e}")
-            return_data["msg"] = "处理接口返回信息时出错"
-        return return_data
-
-
-    async def shapan(self,server: str = "眉间雪"):
-        return_data = {
-            "code": 0,
-            "msg": "功能函数未执行",
-            "data": {}
-        }
-        #在配置文件中获取接口配置
-        api_config = self.__api_config["aijx3_shapan"]
-        #更新参数
-        api_config["params"]["serverName"] = server
-        # 获取数据
-        data = await self.__api.post(api_config["url"],api_config["params"],"data")         
-        if not data:
-            return_data["msg"] = "获取接口信息失败"
-            return  return_data        
-        # 处理返回数据
-        try:
-            return_data["data"] = data.get("picUrl")
-            return_data["code"] = 200       
-        except Exception as e:
-            logger.error(f"处理数据时出错: {e}")
-            return_data["msg"] = "处理接口返回信息时出错"
-        return return_data
-
-
-    async def shaohua(self):
-        return_data = {
-            "code": 0,
-            "msg": "功能函数未执行",
-            "data": {}
-        }
-        #在配置文件中获取接口配置
-        api_config = self.__api_config["jx3_shaohua"]
-        # 获取数据
-        data = await self.__api.get(api_config["url"],api_config["params"],"data")         
-        if not data:
-            return_data["msg"] = "获取接口信息失败"
-            return  return_data        
-        # 处理返回数据
-        try:
-            return_data["data"] = data.get("text")
-            return_data["code"] = 200       
-        except Exception as e:
-            logger.error(f"处理数据时出错: {e}")
-            return_data["msg"] = "处理接口返回信息时出错"
-        return return_data
-
-
-    async def jigai(self):
-        return_data = {
-            "code": 0,
-            "msg": "功能函数未执行",
-            "data": {}
-        }
-        #在配置文件中获取接口配置
-        api_config = self.__api_config["jx3_jigai"]
-        # 获取数据
-        data = await self.__api.get(api_config["url"],api_config["params"],"data")         
-        if not data:
-            return_data["msg"] = "获取接口信息失败"
-            return  return_data 
-        # 处理返回数据
-        try:
-            result_msg = f"剑网三最近技改\n"
-            for i, item in enumerate(data[:2], 1):
-                result_msg += f"{i}. {item.get('title', '无标题')}\n"
-                result_msg += f"时间：{item.get('time', '未知时间')}\n"
-                result_msg += f"链接：{item.get('url', '无链接')}\n\n"
-            return_data["data"] = result_msg
-            return_data["code"] = 200          
-        except Exception as e:
-            logger.error(f"处理数据时出错: {e}")
-            return_data["msg"] = "处理接口返回信息时出错"
-        return return_data

main.py

@@ -11,7 +11,6 @@ from .core.load_template import load_template
 from .core.jx3_data import jx3_data_jiaoyihang,jx3_data_wujia
 from .core.api_data import APIClient,api_data_get, api_data_post
 from .core.sql_data import sql_data_searchdata,sql_data_select
-from .core.jx3_Function import JX3Function
 
 
 @register("astrbot_plugin_jx3api", 
@@ -37,43 +36,32 @@ class Jx3ApiPlugin(Star):
     async def initialize(self):
         """可选择实现异步的插件初始化方法，当实例化该插件类之后会自动调用该方法。"""
         #创建类实例
-        self.jx3fun = JX3Function(self.api_config)
+        self.api_data = APIClient()
         logger.info("jx3api插件创建实例完成")
 
+    async def message_str(self, event: AstrMessageEvent):
+        """可选择实现异步的消息预处理方法，在消息分发到具体命令前会调用该方法。"""
+        # 预处理消息内容
+        message_str = event.message_str.strip()
+        return message_str.split()
 
+    @filter.command("剑三日常")
+    async def jx3_richang(self, event: AstrMessageEvent):
+        """剑三日常"""
+        # 接口URL
+        custom_url = "https://www.jx3api.com/data/active/calendar"  
+        # 接口参数
+        params = {
+            "server": "眉间雪",  # 服务器
+            "num": 0  # 当天
+        }
+        # 获取消息内容
+        parts = await self.message_str(event)
+        # 解析消息内容
+        if len(parts) > 1:
+            params["server"] = parts[1]  
 
-    @filter.command_group("剑三")
+<<<<<<< HEAD
-    def jx3(self):
-        pass
-
-    @jx3.command("日常")
-    async def jx3_richang(self, event: AstrMessageEvent,server: str = "眉间雪",num: int = 0):
-        """剑三 日常 服务器 天数"""
-        try:
-            data= await self.jx3fun.richang(server,num)
-            if data["code"] == 200:
-                yield event.plain_result(data["data"])
-            else:
-                yield event.plain_result("msg")
-            return
-        except Exception as e:
-            logger.error(f"功能函数执行错误: {e}")
-            yield event.plain_result("猪脑过载，请稍后再试")
-    
-    @jx3.command("沙盘")
-    async def jx3_shapan(self, event: AstrMessageEvent,server: str = "眉间雪"):
-        """剑三 沙盘 服务器"""
-        try:
-            data= await self.jx3fun.shapan(server)
-            if data["code"] == 200:
-                yield event.image_result(data["data"])
-            else:
-                yield event.plain_result(data["msg"])
-            return
-        except Exception as e:
-            logger.error(f"功能函数执行错误: {e}")
-            yield event.plain_result("猪脑过载，请稍后再试")        
-
 
     @jx3.command("骚话")
     async def jx3_shaohua(self, event: AstrMessageEvent,):
@@ -84,25 +72,110 @@ class Jx3ApiPlugin(Star):
                 yield event.plain_result(data["data"])
             else:
                 yield event.plain_result(data["msg"])
-            return
+=======
-        except Exception as e:
+        if len(parts) > 2:
-            logger.error(f"功能函数执行错误: {e}")
-            yield event.plain_result("猪脑过载，请稍后再试") 
-
-
-    @jx3.command("技改")
-    async def jx3_jigai(self, event: AstrMessageEvent,):
-        """剑三 技改"""
             try:
-            data= await self.jx3fun.jigai()
+                params["num"] = int(parts[2])  
-            if data["code"] == 200:
+            except ValueError:
-                yield event.plain_result(data["data"])
+                params["num"] = 0  
-            else:
+
-                yield event.plain_result(data["msg"])
+        # 获取数据
+        data = await self.api_data.request(self.api_config["jx3_richang"],"data")
+        
+        if not data:
+            yield event.plain_result("获取获取接口信息失败，请稍后再试")
+>>>>>>> ecb573761ec04986a07da4a19511ef52e9f36ec6
             return
+        
+        # 处理返回数据
+        try:
+            # 构建回复消息
+            result_msg = f"{params['server']}-{data.get('date')}-星期{data.get('week')}\n"
+            result_msg += f"大战：{data.get('war')}\n"
+            result_msg += f"战场：{data.get('battle')}\n"
+            result_msg += f"阵营：{data.get('orecar')}\n"
+            result_msg += f"宗门：{data.get('school')}\n"
+            result_msg += f"驰援：{data.get('rescue')}\n"
+            result_msg += f"画像：{data.get('draw')}\n"
+            result_msg += f"宠物福缘：\n{data.get('luck')}\n"
+            result_msg += f"家园声望：\n{data.get('card')}\n"
+            result_msg += f"武林通鉴：\n{data.get('team')}\n"
+
+            yield event.plain_result(result_msg)
+            
         except Exception as e:
-            logger.error(f"功能函数执行错误: {e}")
+            logger.error(f"处理数据时出错: {e}")
-            yield event.plain_result("猪脑过载，请稍后再试") 
+            yield event.plain_result("处理接口返回信息时出错")
+
+
+    @filter.command("剑三骚话")
+    async def jx3_shaohua(self, event: AstrMessageEvent):
+        """剑三骚话"""
+        # 接口URL
+        custom_url = "https://www.jx3api.com/data/saohua/random"  
+        # 接口参数
+        params = {
+            "name": "万花",  # 默认值
+        }
+        
+        # 获取消息内容
+
+        # 解析消息内容
+        
+        # 获取数据
+        data = api_data_get(custom_url, params,"data")
+        
+        if not data:
+            yield event.plain_result("获取获取接口信息失败，请稍后再试")
+            return
+        
+        # 处理返回数据
+        try:
+            # 构建回复消息
+            result_msg = f"{data.get('text')}\n"
+
+            yield event.plain_result(result_msg)
+            
+        except Exception as e:
+            logger.error(f"处理数据时出错: {e}")
+            yield event.plain_result("处理接口返回信息时出错")
+
+
+    @filter.command("剑三技改")
+    async def jx3_jigai(self, event: AstrMessageEvent):
+        """剑三技改"""
+        # 接口URL
+        custom_url = "https://www.jx3api.com/data/skills/records"  
+        # 接口参数
+        params = {
+            
+        }
+        
+        # 获取消息内容
+
+        # 解析消息内容
+        
+        # 获取数据
+        data = api_data_get(custom_url,params,"data")
+        
+        if not data:
+            yield event.plain_result("获取获取接口信息失败，请稍后再试")
+            return
+        
+        # 处理返回数据
+        try:
+            # 构建回复消息
+            result_msg = f"剑网三最近技改\n"
+            for i, item in enumerate(data[:2], 1):
+                result_msg += f"{i}. {item.get('title', '无标题')}\n"
+                result_msg += f"时间：{item.get('time', '未知时间')}\n"
+                result_msg += f"链接：{item.get('url', '无链接')}\n\n"
+
+            yield event.plain_result(result_msg)
+            
+        except Exception as e:
+            logger.error(f"处理数据时出错: {e}")
+            yield event.plain_result("处理接口返回信息时出错")
 
 
     @filter.command("剑三交易行")
@@ -161,7 +234,38 @@ class Jx3ApiPlugin(Star):
             yield event.plain_result("查询交易行数据时出错，请稍后再试")
 
 
+    @filter.command("剑三沙盘")
+    async def jx3_shapan(self, event: AstrMessageEvent):
+        """剑三沙盘 服务器"""
+        # 接口URL
+        custom_url = "https://www.jianxiachaguan.cn/api2/aijx3-jxcg/game/get-sand-table-img"  
+        # 接口参数
+        params = {
+                "serverName": "眉间雪"  # 默认服务器
+        }
 
+        # 获取消息内容
+        message_str = event.message_str.strip()
+        parts = message_str.split()
+        # 解析消息内容
+        if len(parts) > 1:
+            params["serverName"] = parts[1]  # 第二个参数为服务器
+
+        # 获取数据
+        data = api_data_post(custom_url,params,"data")
+        
+        if not data:
+            yield event.plain_result("获取获取接口信息失败，请稍后再试")
+            return
+        
+        # 处理返回数据
+        try:
+            # 构建回复消息
+            yield event.image_result(data.get("picUrl"))
+            
+        except Exception as e:
+            logger.error(f"处理数据时出错: {e}")
+            yield event.plain_result("处理接口返回信息时出错")
 
 
     @filter.command("剑三金价")