koishi-plugin-jscn-aaaquery 1.0.2 → 1.0.4

package/lib/index.d.ts

@@ -4,6 +4,7 @@ export interface Config {
     loginName: string;
     password: string;
     baseUrl: string;
+    radiusApiUrl?: string;
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -28,10 +28,29 @@ module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
 var name = "jscn-aaaquery";
 var Config = import_koishi.Schema.object({
-  loginName: import_koishi.Schema.string().required().description("运维系统登录账号"),
-  password: import_koishi.Schema.string().required().description("运维系统登录密码"),
-  baseUrl: import_koishi.Schema.string().default("http://172.16.251.75:8090/nms/api").description("运维系统API地址")
+  loginName: import_koishi.Schema.string().required().description("运维系统登录账号").default("admin"),
+  password: import_koishi.Schema.string().required().description("运维系统登录密码").default("admin"),
+  baseUrl: import_koishi.Schema.string().default("http://172.16.251.75:8090/nms/api").description("运维系统API地址"),
+  // 添加RADIUS API的配置项
+  radiusApiUrl: import_koishi.Schema.string().description("RADIUS API基础URL").default("http://111.208.114.248:28210/api/radius")
 });
+function evaluateOpticalPower(power) {
+  if (power === "设备不在线" || power === void 0 || power === null) {
+    return "";
+  }
+  const powerValue = parseFloat(power);
+  if (isNaN(powerValue)) {
+    return "";
+  }
+  if (powerValue >= -24 && powerValue <= -8) {
+    return "🟢正常";
+  } else if (powerValue > -8) {
+    return "🔴过高";
+  } else {
+    return "🔴过低";
+  }
+}
+__name(evaluateOpticalPower, "evaluateOpticalPower");
 function apply(ctx, config) {
   let currentToken = null;
   let tokenExpireTime = 0;
@@ -44,6 +63,11 @@ function apply(ctx, config) {
   const MAX_CONCURRENT_REQUESTS = 10;
   let currentConcurrentRequests = 0;
   const requestWaitQueue = [];
+  const messageQueue = [];
+  let isProcessingMessage = false;
+  const MESSAGE_TIMEOUT = 2 * 60 * 1e3;
+  const MESSAGE_CLEAN_INTERVAL = 60 * 1e3;
+  const MAX_QUEUE_LENGTH = 50;
   function getCacheKey(type, params) {
     return `${type}:${JSON.stringify(params)}`;
   }
@@ -127,7 +151,7 @@ function apply(ctx, config) {
   }
   __name(addToQueue, "addToQueue");
   function formatMacAddress(mac) {
-    return mac.replace(/[:-\s.]/g, "").toLowerCase();
+    return mac.replace(/[:-\s.：。－｜]/g, "").toLowerCase();
   }
   __name(formatMacAddress, "formatMacAddress");
   function isValidMacAddress(mac) {
@@ -203,7 +227,7 @@ function apply(ctx, config) {
         console.log("查询响应:", JSON.stringify(response, null, 2));
         if (response.status === 200 && response.data) {
           if (!isAccountResponseComplete(response.data)) {
-            throw new Error("账号信息不完整，请检查账号是否正确");
+            throw new Error("账号信息有误，请检查账号是否正确");
           }
           setCache("account", { account: formattedAccount }, response.data);
           return response.data;
@@ -308,32 +332,42 @@ function apply(ctx, config) {
         });
         console.log("查询响应:", JSON.stringify(response, null, 2));
         if (response.status === 200 && response.data) {
-          if (response.data.status === 1 && (response.data.onuReceivePower === "0" || response.data.onuSendPower === "0")) {
-            console.log("设备在线但光功率为0，尝试刷新光功率...");
-            try {
-              const powerResponse = await ctx.http.get(
-                `${config.baseUrl}/fttx/onu/refreshOnuPower`,
-                {
-                  params: {
-                    cid: response.data.cid,
-                    gponIndex: response.data.gponIndex,
-                    onuIndex: response.data.onuIndex
-                  },
-                  headers: {
-                    "Authorization": token,
-                    "Accept": "application/json",
-                    "Content-Type": "application/json"
-                  }
+          console.log("尝试刷新设备光功率...");
+          try {
+            const powerResponse = await ctx.http.get(
+              `${config.baseUrl}/fttx/onu/refreshOnuPower`,
+              {
+                params: {
+                  cid: response.data.cid,
+                  gponIndex: response.data.gponIndex,
+                  onuIndex: response.data.onuIndex
+                },
+                headers: {
+                  "Authorization": token,
+                  "Accept": "application/json",
+                  "Content-Type": "application/json"
                 }
-              );
-              if (powerResponse.status === 200 && powerResponse.data) {
-                console.log("光功率刷新成功:", powerResponse.data);
+              }
+            );
+            if (powerResponse.status === 200 && powerResponse.data) {
+              console.log("光功率刷新结果:", powerResponse.data);
+              if (powerResponse.data.status !== void 0) {
+                response.data.status = powerResponse.data.status;
+              }
+              if (response.data.status !== 1 && (powerResponse.data.onuReceivePower === void 0 || powerResponse.data.onuSendPower === void 0)) {
+                response.data.onuReceivePower = "设备不在线";
+                response.data.onuSendPower = "设备不在线";
+              } else {
                 response.data.onuReceivePower = powerResponse.data.onuReceivePower;
                 response.data.onuSendPower = powerResponse.data.onuSendPower;
-                response.data.statusHealth = powerResponse.data.statusHealth;
               }
-            } catch (error) {
-              console.error("刷新光功率失败:", error);
+              response.data.statusHealth = powerResponse.data.statusHealth;
+            }
+          } catch (error) {
+            console.error("刷新光功率过程中出错:", error);
+            if (response.data.status !== 1 && (response.data.onuReceivePower === void 0 || response.data.onuReceivePower === null || response.data.onuSendPower === void 0 || response.data.onuSendPower === null)) {
+              response.data.onuReceivePower = "设备不在线";
+              response.data.onuSendPower = "设备不在线";
             }
           }
           setCache("onuDetail", { onuId }, response.data);
@@ -451,7 +485,7 @@ function apply(ctx, config) {
     });
   }
   __name(queryOnuDetailVlanInfo, "queryOnuDetailVlanInfo");
-  async function queryOrderLog(mac, startTime, endTime) {
+  async function queryOrderLog(mac, startTime, endTime, token) {
     const cacheKey = { mac, startTime, endTime };
     const cachedData = getFromCache("orderLog", cacheKey);
     if (cachedData) {
@@ -461,7 +495,6 @@ function apply(ctx, config) {
     return addToQueue("orderLog", cacheKey, async () => {
       try {
         console.log("开始查询工单日志...");
-        const token = await getToken();
         const formattedMac = formatMacAddress(mac);
         console.log("处理后的MAC地址:", formattedMac);
         const response = await ctx.http.get(`${config.baseUrl}/fttx/orderAnalyBlock/selectorderAnalyBlockOneList`, {
@@ -486,351 +519,697 @@ function apply(ctx, config) {
     });
   }
   __name(queryOrderLog, "queryOrderLog");
-  ctx.middleware(async (session, next) => {
-    const input = session.content.trim();
-    if (input.includes(" ") || /[\u4e00-\u9fa5]/.test(input)) {
-      return next();
+  async function queryRadiusUser(account) {
+    const cachedData = getFromCache("radiusUser", { account });
+    if (cachedData) {
+      console.log("使用缓存的RADIUS用户信息");
+      return cachedData;
     }
-    const cleanInput = formatMacAddress(input);
-    console.log("处理后的内容:", cleanInput);
-    if (isValidMacAddress(cleanInput)) {
+    return addToQueue("radiusUser", { account }, async () => {
       try {
-        const onuList = await queryOnuList(cleanInput);
-        if (!onuList) {
-          return "未找到该MAC地址的设备信息";
-        }
-        const onuDetail = await queryOnuDetailInfo(onuList.id);
-        const ccname = await queryCCName(cleanInput);
-        const order = await queryOnuOrder(onuDetail);
-        const vlanInfo = await queryOnuDetailVlanInfo(onuList.id);
-        const messages = [
-          "📊 终端基本信息",
-          "--------------------------------",
-          `MAC地址: ${cleanInput}`,
-          `状态：${onuDetail.status === 1 ? "在线" : "不在线"}`,
-          `机房: ${onuDetail.roomName}`,
-          `设备名称: ${onuDetail.deviceName}`,
-          `OLT IP: ${onuDetail.oltIp}`,
-          `PON端口: ${onuDetail.portName}`,
-          `端口逻辑号: ${onuDetail.logicId}`,
-          `发射光功率: ${onuDetail.onuSendPower}dBm`,
-          `接收光功率: ${onuDetail.onuReceivePower}dBm`,
-          `CCName: ${ccname}`,
-          "",
-          "📝 工单信息",
-          "--------------------------------",
-          order ? [
-            `工单编号: ${order.orderId}`,
-            `创建时间: ${order.createDate}`,
-            `更新时间: ${order.updateDate}`
-          ].join("\n") : "无工单信息",
-          "",
-          "🔧 业务配置信息",
-          "--------------------------------"
-        ];
-        vlanInfo.forEach((info) => {
-          messages.push(
-            `端口 ${info.LAN}:`,
-            `  VLAN: ${info.actualVlan}`
-          );
-        });
-        return messages.join("\n");
-      } catch (error) {
-        console.error("查询过程出错:", error);
-        return "查询失败，请稍后重试";
-      }
-    } else {
-      try {
-        const accountInfo = await queryAccount(input);
-        const message = [
-          "📊 账号查询结果",
-          "--------------------------------",
-          `账号: ${accountInfo.accessUserName}`,
-          `状态: ${accountInfo.onlineStatus}`,
-          `认证: ${accountInfo.isPass}`,
-          `IP地址: ${accountInfo.userIp}`,
-          `MAC地址: ${accountInfo.mac}`,
-          `最大上行: ${accountInfo.maxUpSpeed}Mbps`,
-          `最大下行: ${accountInfo.maxDownSpeed}Mbps`,
-          `接入域: ${accountInfo.accessDomain}`,
-          `开始时间: ${accountInfo.startTime}`,
-          `在线时长: ${accountInfo.startTimeSum}分钟`,
-          `设备名称: ${accountInfo.nickName}`
-        ].join("\n");
-        return message;
+        console.log("开始查询RADIUS用户信息...");
+        const response = await ctx.http.post(
+          `${config.radiusApiUrl}/userquery`,
+          {
+            login_name: account,
+            org_code: "403",
+            // 固定值
+            channel: "ALL"
+            // 固定值
+          },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              "Accept": "application/json"
+            }
+          }
+        );
+        console.log("查询响应:", JSON.stringify(response, null, 2));
+        setCache("radiusUser", { account }, response);
+        return response;
       } catch (error) {
-        console.error("查询过程出错:", error);
-        return error.message || "查询失败，请检查账号是否正确";
+        console.error("查询RADIUS用户错误详情:", error);
+        if (error.response) {
+          console.error("错误响应:", error.response.data);
+        }
+        throw error;
       }
+    });
+  }
+  __name(queryRadiusUser, "queryRadiusUser");
+  function formatRadiusTime(timeString) {
+    if (!timeString || timeString.length < 14) return "未知时间";
+    const year = timeString.substring(0, 4);
+    const month = timeString.substring(4, 6);
+    const day = timeString.substring(6, 8);
+    const hour = timeString.substring(8, 10);
+    const minute = timeString.substring(10, 12);
+    const second = timeString.substring(12, 14);
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+  }
+  __name(formatRadiusTime, "formatRadiusTime");
+  function translateOrderStatus(status) {
+    switch (status) {
+      case "active":
+        return "有效";
+      case "inactive":
+        return "无效";
+      case "suspend":
+        return "暂停";
+      default:
+        return status;
     }
-  });
-  ctx.command("账号查询 <account:string>", "查询宽带账号状态").action(async (_, account) => {
-    if (!account) return "请输入要查询的账号";
-    try {
-      const accountInfo = await queryAccount(account);
-      const message = [
-        "📊 账号查询结果",
-        "--------------------------------",
-        `账号: ${accountInfo.accessUserName}`,
-        `状态: ${accountInfo.onlineStatus}`,
-        `认证: ${accountInfo.isPass}`,
-        `IP地址: ${accountInfo.userIp}`,
-        `MAC地址: ${accountInfo.mac}`,
-        `最大上行: ${accountInfo.maxUpSpeed}Mbps`,
-        `最大下行: ${accountInfo.maxDownSpeed}Mbps`,
-        `接入域: ${accountInfo.accessDomain}`,
-        `开始时间: ${accountInfo.startTime}`,
-        `在线时长: ${accountInfo.startTimeSum}分钟`,
-        `设备名称: ${accountInfo.nickName}`
-      ].join("\n");
-      return message;
-    } catch (error) {
-      console.error("查询过程出错:", error);
-      return error.message || "查询失败，请检查账号是否正确";
+  }
+  __name(translateOrderStatus, "translateOrderStatus");
+  function translateUserStatus(status) {
+    switch (status) {
+      case "active":
+        return "正常";
+      case "inactive":
+        return "停用";
+      case "suspend":
+        return "暂停";
+      default:
+        return status;
     }
-  });
-  ctx.command("账号详情 <account:string>", "查询宽带账号详细记录").action(async (_, account) => {
-    if (!account) return "请输入要查询的账号";
+  }
+  __name(translateUserStatus, "translateUserStatus");
+  function processTimeRange(startTime, endTime) {
+    const formatDate = /* @__PURE__ */ __name((date) => {
+      const year = date.getFullYear();
+      const month = String(date.getMonth() + 1).padStart(2, "0");
+      const day = String(date.getDate()).padStart(2, "0");
+      return `${year}-${month}-${day}`;
+    }, "formatDate");
+    const parseDate = /* @__PURE__ */ __name((dateStr) => {
+      if (dateStr.includes(".") || dateStr.includes("/")) {
+        const parts = dateStr.split(/[./]/);
+        if (parts.length === 3) {
+          const [year, month, day] = parts.map(Number);
+          return new Date(year, month - 1, day);
+        } else if (parts.length === 2) {
+          const [month, day] = parts.map(Number);
+          const year = (/* @__PURE__ */ new Date()).getFullYear();
+          return new Date(year, month - 1, day);
+        }
+      }
+      const chineseMonthMap = {
+        "一": 1,
+        "二": 2,
+        "三": 3,
+        "四": 4,
+        "五": 5,
+        "六": 6,
+        "七": 7,
+        "八": 8,
+        "九": 9,
+        "十": 10,
+        "十一": 11,
+        "十二": 12
+      };
+      const chineseDayMap = {
+        "一": 1,
+        "二": 2,
+        "三": 3,
+        "四": 4,
+        "五": 5,
+        "六": 6,
+        "七": 7,
+        "八": 8,
+        "九": 9,
+        "十": 10,
+        "十一": 11,
+        "十二": 12,
+        "十三": 13,
+        "十四": 14,
+        "十五": 15,
+        "十六": 16,
+        "十七": 17,
+        "十八": 18,
+        "十九": 19,
+        "二十": 20,
+        "二十一": 21,
+        "二十二": 22,
+        "二十三": 23,
+        "二十四": 24,
+        "二十五": 25,
+        "二十六": 26,
+        "二十七": 27,
+        "二十八": 28,
+        "二十九": 29,
+        "三十": 30,
+        "三十一": 31
+      };
+      const monthMatch = dateStr.match(/[一二三四五六七八九十]+月/);
+      const dayMatch = dateStr.match(/[一二三四五六七八九十]+[号日]/);
+      if (monthMatch && dayMatch) {
+        const monthStr = monthMatch[0].replace("月", "");
+        const dayStr = dayMatch[0].replace(/[号日]/, "");
+        const year = (/* @__PURE__ */ new Date()).getFullYear();
+        const month = chineseMonthMap[monthStr];
+        const day = chineseDayMap[dayStr];
+        return new Date(year, month - 1, day);
+      }
+      throw new Error("不支持的日期格式");
+    }, "parseDate");
+    let formattedStartTime;
+    let formattedEndTime;
     try {
-      const records = await queryAccountDetail(account);
-      if (records.length === 0) {
-        return "未找到该账号的详细记录";
+      if (startTime && endTime) {
+        formattedStartTime = formatDate(parseDate(startTime));
+        formattedEndTime = formatDate(parseDate(endTime));
+      } else if (startTime) {
+        const endDate = parseDate(startTime);
+        const startDate = new Date(endDate);
+        startDate.setDate(startDate.getDate() - 1);
+        formattedStartTime = formatDate(startDate);
+        formattedEndTime = formatDate(endDate);
+      } else {
+        const today = /* @__PURE__ */ new Date();
+        const yesterday = new Date(today);
+        yesterday.setDate(yesterday.getDate() - 1);
+        formattedStartTime = formatDate(yesterday);
+        formattedEndTime = formatDate(today);
       }
-      const messages = records.map((record, index) => [
-        `📝 记录 #${index + 1}`,
-        "--------------------------------",
-        `账号: ${record.accessUserName}`,
-        `记录类型: ${record.recordType}`,
-        `设备名称: ${record.nickName}`,
-        `IP地址: ${record.ip}`,
-        `MAC地址: ${record.mac}`,
-        `登录时间: ${record.userLoginInTime}`,
-        `登出时间: ${record.userLoginOutTime}`,
-        `原因: ${record.reason || "无"}`
-      ].join("\n"));
-      return messages.join("\n\n");
     } catch (error) {
-      console.error("查询过程出错:", error);
-      return error.message || "查询失败，请稍后重试";
+      throw new Error("日期格式错误，支持的格式：\n1. 2025.4.4 或 2025/4/4\n2. 4.7 或 4/7（自动补全当前年份）\n3. 四月五号\n4. 四月五日");
     }
-  });
-  ctx.command("终端查询 <mac:string>", "查询终端基本信息").action(async (_, mac) => {
-    if (!mac) return "请输入要查询的MAC地址";
+    return { formattedStartTime, formattedEndTime };
+  }
+  __name(processTimeRange, "processTimeRange");
+  function isShortPrompt(message) {
+    return !message.includes("\n") && message.length < 30;
+  }
+  __name(isShortPrompt, "isShortPrompt");
+  function formatOutputMessage(message) {
+    if (isShortPrompt(message)) {
+      return message;
+    }
+    if (!message.trim().endsWith("--------------------------------")) {
+      message = message + "\n--------------------------------";
+    }
+    return "\n" + message;
+  }
+  __name(formatOutputMessage, "formatOutputMessage");
+  async function processMessageQueue() {
+    if (isProcessingMessage || messageQueue.length === 0) return;
+    isProcessingMessage = true;
     try {
-      const formattedMac = formatMacAddress(mac);
-      const onuList = await queryOnuList(formattedMac);
-      if (!onuList) {
-        return "未找到该MAC地址的设备信息";
+      const task = messageQueue.shift();
+      if (!task) {
+        isProcessingMessage = false;
+        return;
       }
-      const onuDetail = await queryOnuDetailInfo(onuList.id);
-      const vlanInfo = await queryOnuDetailVlanInfo(onuList.id);
-      const messages = [
-        "📊 终端基本信息",
-        "--------------------------------",
-        `MAC地址: ${formattedMac}`,
-        `状态：${onuDetail.status === 1 ? "在线" : "不在线"}`,
-        `发射光功率: ${onuDetail.onuSendPower}dBm`,
-        `接收光功率: ${onuDetail.onuReceivePower}dBm`,
-        "",
-        "🔧 业务配置信息",
-        "--------------------------------"
-      ];
-      vlanInfo.forEach((info) => {
-        messages.push(
-          `端口 ${info.LAN}:`,
-          `  VLAN: ${info.actualVlan}`
-        );
-      });
-      return messages.join("\n");
+      if (Date.now() - task.timestamp > MESSAGE_TIMEOUT) {
+        console.log("消息处理任务超时，跳过处理");
+        isProcessingMessage = false;
+        setTimeout(processMessageQueue, 0);
+        return;
+      }
+      console.log("开始处理消息队列中的任务");
+      const result = await task.handler();
+      if (result && task.session?.send) {
+        const formattedResult = formatOutputMessage(result);
+        await task.session.send(formattedResult);
+      }
+      console.log("消息处理完成");
     } catch (error) {
-      console.error("查询过程出错:", error);
-      return "查询失败，请稍后重试";
+      console.error("处理消息队列任务出错:", error);
+    } finally {
+      isProcessingMessage = false;
+      setTimeout(processMessageQueue, 100);
     }
-  });
-  ctx.command("终端详细查询 <mac:string>", "查询终端详细信息").action(async (_, mac) => {
-    if (!mac) return "请输入要查询的MAC地址";
-    try {
-      const formattedMac = formatMacAddress(mac);
-      const onuList = await queryOnuList(formattedMac);
-      if (!onuList) {
-        return "未找到该MAC地址的设备信息";
+  }
+  __name(processMessageQueue, "processMessageQueue");
+  function addToMessageQueue(session, handler) {
+    if (messageQueue.length >= MAX_QUEUE_LENGTH) {
+      const oldestTask = messageQueue.shift();
+      if (oldestTask?.session?.send) {
+        oldestTask.session.send("系统繁忙，请稍后再试").catch((error) => console.error("发送繁忙提示失败:", error));
       }
-      const onuDetail = await queryOnuDetailInfo(onuList.id);
-      const ccname = await queryCCName(formattedMac);
-      const order = await queryOnuOrder(onuDetail);
-      const vlanInfo = await queryOnuDetailVlanInfo(onuList.id);
-      const messages = [
-        "📊 终端基本信息",
-        "--------------------------------",
-        `MAC地址: ${formattedMac}`,
-        `状态：${onuDetail.status === 1 ? "在线" : "不在线"}`,
-        `机房: ${onuDetail.roomName}`,
-        `设备名称: ${onuDetail.deviceName}`,
-        `OLT IP: ${onuDetail.oltIp}`,
-        `PON端口: ${onuDetail.portName}`,
-        `端口逻辑号: ${onuDetail.logicId}`,
-        `发射光功率: ${onuDetail.onuSendPower}dBm`,
-        `接收光功率: ${onuDetail.onuReceivePower}dBm`,
-        `CCName: ${ccname}`,
-        "",
-        "📝 工单信息",
-        "--------------------------------",
-        order ? [
-          `工单编号: ${order.orderId}`,
-          `创建时间: ${order.createDate}`,
-          `更新时间: ${order.updateDate}`
-        ].join("\n") : "无工单信息",
-        "",
-        "🔧 业务配置信息",
-        "--------------------------------"
-      ];
-      vlanInfo.forEach((info) => {
-        messages.push(
-          `端口 ${info.LAN}:`,
-          `  VLAN: ${info.actualVlan}`
-        );
-      });
-      return messages.join("\n");
-    } catch (error) {
-      console.error("查询过程出错:", error);
-      return "查询失败，请稍后重试";
     }
+    messageQueue.push({
+      session,
+      handler,
+      timestamp: Date.now()
+    });
+    setTimeout(processMessageQueue, 0);
+  }
+  __name(addToMessageQueue, "addToMessageQueue");
+  setInterval(() => {
+    const now = Date.now();
+    let expiredCount = 0;
+    while (messageQueue.length > 0 && now - messageQueue[0].timestamp > MESSAGE_TIMEOUT) {
+      const expiredTask = messageQueue.shift();
+      if (expiredTask?.session?.send) {
+        expiredTask.session.send("处理超时，请稍后再试").catch((error) => console.error("发送超时提示失败:", error));
+      }
+      expiredCount++;
+    }
+    if (expiredCount > 0) {
+      console.log(`清理了 ${expiredCount} 个超时的消息任务`);
+    }
+  }, MESSAGE_CLEAN_INTERVAL);
+  ctx.middleware(async (session, next) => {
+    console.log("原始消息:", session.content);
+    const originalInput = session.stripped.content.trim();
+    let input = originalInput;
+    console.log("处理后的消息:", input);
+    if (!input) {
+      console.log("处理后的消息为空，跳过智能查询");
+      return next();
+    }
+    if (/[\u4e00-\u9fa5]/.test(input)) {
+      console.log("消息包含中文，跳过智能查询");
+      return next();
+    }
+    return new Promise((resolve) => {
+      addToMessageQueue(session, async () => {
+        try {
+          const cleanInput = formatMacAddress(input);
+          console.log("处理后的内容:", cleanInput);
+          if (isValidMacAddress(cleanInput)) {
+            console.log("内容是合法的MAC地址，开始查询");
+            try {
+              const onuList = await queryOnuList(cleanInput);
+              if (!onuList) {
+                return "未找到该MAC地址的设备信息";
+              }
+              const onuDetail = await queryOnuDetailInfo(onuList.id);
+              const ccname = await queryCCName(cleanInput);
+              const order = await queryOnuOrder(onuDetail);
+              const vlanInfo = await queryOnuDetailVlanInfo(onuList.id);
+              const messages = [
+                "🖥️ 终端基本信息",
+                "--------------------------------",
+                `MAC地址: ${cleanInput}`,
+                `状态：${onuDetail.status === 1 ? "在线 ✅" : "不在线 ❌"}`,
+                `机房: ${onuDetail.roomName}`,
+                `设备名称: `,
+                `${onuDetail.deviceName}`,
+                `OLT IP: ${onuDetail.oltIp}`,
+                `PON端口: ${onuDetail.portName}`,
+                `端口逻辑号: ${onuDetail.logicId}`,
+                `发射光功率: ${onuDetail.onuSendPower === "设备不在线" ? "设备不在线" : onuDetail.onuSendPower + "dBm"}`,
+                `接收光功率: ${onuDetail.onuReceivePower === "设备不在线" ? "设备不在线" : onuDetail.onuReceivePower + "dBm"}${onuDetail.onuReceivePower !== "设备不在线" ? " " + evaluateOpticalPower(onuDetail.onuReceivePower) : ""}`,
+                `CCName: ${ccname}`,
+                "",
+                "📃 工单信息",
+                "--------------------------------",
+                order ? [
+                  `工单编号: ${order.orderId}`,
+                  `创建时间: ${order.createDate}`,
+                  `更新时间: ${order.updateDate}`
+                ].join("\n") : "无工单信息",
+                "",
+                "⚙️ 业务配置信息",
+                "--------------------------------"
+              ];
+              vlanInfo.forEach((info) => {
+                messages.push(
+                  `端口 ${info.LAN}:`,
+                  `  端口VLAN: ${info.VLAN || "未配置"}`,
+                  `  工单VLAN: ${info.actualVlan || "未配置"}`
+                );
+              });
+              messages.push("--------------------------------");
+              return messages.join("\n");
+            } catch (error) {
+              console.error("查询MAC地址过程出错:", error);
+              return "查询失败，请稍后重试";
+            }
+          } else {
+            console.log("内容不是MAC地址，尝试作为账号查询");
+            try {
+              const radiusUserInfo = await queryRadiusUser(input);
+              if (radiusUserInfo.code !== "000000" || !radiusUserInfo.data) {
+                return "账号授权有误，请重新授权";
+              }
+              const { user, orders } = radiusUserInfo.data;
+              const accountInfo = await queryAccount(input);
+              const days = Math.floor(accountInfo.startTimeSum / (60 * 24));
+              const hours = Math.floor(accountInfo.startTimeSum % (60 * 24) / 60);
+              const minutes = accountInfo.startTimeSum % 60;
+              let durationText = "";
+              if (days > 0) {
+                durationText = `${days}天${hours > 0 ? hours + "小时" : ""}${minutes > 0 ? minutes + "分钟" : ""}`;
+              } else if (hours > 0) {
+                durationText = `${hours}小时${minutes > 0 ? minutes + "分钟" : ""}`;
+              } else {
+                durationText = `${minutes}分钟`;
+              }
+              const message = [
+                "🌐 账号查询结果",
+                "--------------------------------",
+                `账号: ${accountInfo.accessUserName}`,
+                // `RADIUS用户密码: ${user.password}`,
+                `RADIUS状态: ${translateUserStatus(user.user_status)} ${user.user_status === "active" ? "✅" : user.user_status === "suspend" ? "⚠️" : "❌"}`,
+                "",
+                `状态: ${accountInfo.onlineStatus} ${accountInfo.onlineStatus.includes("在线") ? "✅" : "❌"}`,
+                `认证: ${accountInfo.isPass} ${accountInfo.isPass.includes("成功") ? "✅" : "❌"}`,
+                `IP地址: ${accountInfo.userIp}`,
+                `MAC地址: ${accountInfo.mac}`,
+                `最大上行: ${accountInfo.maxUpSpeed}Mbps`,
+                `最大下行: ${accountInfo.maxDownSpeed}Mbps`,
+                `开始时间: ${accountInfo.startTime}`,
+                `在线时长: ${durationText}`,
+                ""
+              ];
+              if (orders && orders.length > 0) {
+                message.push("🛒 订购信息");
+                message.push("--------------------------------");
+                orders.forEach((order, index) => {
+                  message.push(
+                    `订购 #${index + 1}:`,
+                    `  订购状态: ${translateOrderStatus(order.order_status)}`,
+                    `  服务名称: ${order.service_name}`,
+                    `  生效时间: ${formatRadiusTime(order.valid_date)}`,
+                    `  失效时间: ${formatRadiusTime(order.expire_date)}`
+                  );
+                  if (index < orders.length - 1) {
+                    message.push("");
+                  }
+                });
+              }
+              message.push("--------------------------------");
+              return message.join("\n");
+            } catch (error) {
+              console.error("查询账号过程出错:", error);
+              resolve(next());
+              return null;
+            }
+          }
+        } catch (error) {
+          console.error("智能查询过程出错:", error);
+          resolve(next());
+          return null;
+        }
+      });
+    });
   });
-  ctx.command("日志查询 <mac:string> [startTime:string] [endTime:string]", "查询终端工单日志").action(async (_, mac, startTime, endTime) => {
-    if (!mac) return "请输入要查询的MAC地址";
-    try {
-      const formatDate = /* @__PURE__ */ __name((date) => {
-        const year = date.getFullYear();
-        const month = String(date.getMonth() + 1).padStart(2, "0");
-        const day = String(date.getDate()).padStart(2, "0");
-        return `${year}-${month}-${day}`;
-      }, "formatDate");
-      const parseDate = /* @__PURE__ */ __name((dateStr) => {
-        if (dateStr.includes(".") || dateStr.includes("/")) {
-          const parts = dateStr.split(/[./]/);
-          if (parts.length === 3) {
-            const [year, month, day] = parts.map(Number);
-            return new Date(year, month - 1, day);
-          } else if (parts.length === 2) {
-            const [month, day] = parts.map(Number);
-            const year = (/* @__PURE__ */ new Date()).getFullYear();
-            return new Date(year, month - 1, day);
+  ctx.command("账号查询 <account:string>", "查询宽带账号状态").action(async ({ session }, account) => {
+    if (!account) return "请输入要查询的账号";
+    return new Promise((resolve) => {
+      addToMessageQueue(session, async () => {
+        try {
+          const radiusUserInfo = await queryRadiusUser(account);
+          if (radiusUserInfo.code !== "000000" || !radiusUserInfo.data) {
+            return "账号授权有误，请重新授权";
           }
+          const { user, orders } = radiusUserInfo.data;
+          const accountInfo = await queryAccount(account);
+          const days = Math.floor(accountInfo.startTimeSum / (60 * 24));
+          const hours = Math.floor(accountInfo.startTimeSum % (60 * 24) / 60);
+          const minutes = accountInfo.startTimeSum % 60;
+          let durationText = "";
+          if (days > 0) {
+            durationText = `${days}天${hours > 0 ? hours + "小时" : ""}${minutes > 0 ? minutes + "分钟" : ""}`;
+          } else if (hours > 0) {
+            durationText = `${hours}小时${minutes > 0 ? minutes + "分钟" : ""}`;
+          } else {
+            durationText = `${minutes}分钟`;
+          }
+          const message = [
+            "🌐 账号查询结果",
+            "--------------------------------",
+            `账号: ${accountInfo.accessUserName}`,
+            // `RADIUS用户密码: ${user.password}`,
+            `RADIUS状态: ${translateUserStatus(user.user_status)} ${user.user_status === "active" ? "✅" : user.user_status === "suspend" ? "⚠️" : "❌"}`,
+            "",
+            `状态: ${accountInfo.onlineStatus} ${accountInfo.onlineStatus.includes("在线") ? "✅" : "❌"}`,
+            `认证: ${accountInfo.isPass} ${accountInfo.isPass.includes("成功") ? "✅" : "❌"}`,
+            `IP地址: ${accountInfo.userIp}`,
+            `MAC地址: ${accountInfo.mac}`,
+            `最大上行: ${accountInfo.maxUpSpeed}Mbps`,
+            `最大下行: ${accountInfo.maxDownSpeed}Mbps`,
+            `开始时间: ${accountInfo.startTime}`,
+            `在线时长: ${durationText}`,
+            ""
+          ];
+          if (orders && orders.length > 0) {
+            message.push("🛒 订购信息");
+            message.push("--------------------------------");
+            orders.forEach((order, index) => {
+              message.push(
+                `订购 #${index + 1}:`,
+                `  订购状态: ${translateOrderStatus(order.order_status)}`,
+                `  服务名称: ${order.service_name}`,
+                `  生效时间: ${formatRadiusTime(order.valid_date)}`,
+                `  失效时间: ${formatRadiusTime(order.expire_date)}`
+              );
+              if (index < orders.length - 1) {
+                message.push("");
+              }
+            });
+          }
+          message.push("--------------------------------");
+          return message.join("\n");
+        } catch (error) {
+          console.error("查询过程出错:", error);
+          return error.message || "查询失败，请检查账号是否正确";
         }
-        const chineseMonthMap = {
-          "一": 1,
-          "二": 2,
-          "三": 3,
-          "四": 4,
-          "五": 5,
-          "六": 6,
-          "七": 7,
-          "八": 8,
-          "九": 9,
-          "十": 10,
-          "十一": 11,
-          "十二": 12
-        };
-        const chineseDayMap = {
-          "一": 1,
-          "二": 2,
-          "三": 3,
-          "四": 4,
-          "五": 5,
-          "六": 6,
-          "七": 7,
-          "八": 8,
-          "九": 9,
-          "十": 10,
-          "十一": 11,
-          "十二": 12,
-          "十三": 13,
-          "十四": 14,
-          "十五": 15,
-          "十六": 16,
-          "十七": 17,
-          "十八": 18,
-          "十九": 19,
-          "二十": 20,
-          "二十一": 21,
-          "二十二": 22,
-          "二十三": 23,
-          "二十四": 24,
-          "二十五": 25,
-          "二十六": 26,
-          "二十七": 27,
-          "二十八": 28,
-          "二十九": 29,
-          "三十": 30,
-          "三十一": 31
-        };
-        const monthMatch = dateStr.match(/[一二三四五六七八九十]+月/);
-        const dayMatch = dateStr.match(/[一二三四五六七八九十]+[号日]/);
-        if (monthMatch && dayMatch) {
-          const monthStr = monthMatch[0].replace("月", "");
-          const dayStr = dayMatch[0].replace(/[号日]/, "");
-          const year = (/* @__PURE__ */ new Date()).getFullYear();
-          const month = chineseMonthMap[monthStr];
-          const day = chineseDayMap[dayStr];
-          return new Date(year, month - 1, day);
+      });
+      resolve();
+    });
+  });
+  ctx.command("账号详情 <account:string>", "查询宽带账号详细记录").action(async ({ session }, account) => {
+    if (!account) return "请输入要查询的账号";
+    return new Promise((resolve) => {
+      addToMessageQueue(session, async () => {
+        try {
+          const records = await queryAccountDetail(account);
+          if (records.length === 0) {
+            return "未找到该账号的详细记录";
+          }
+          const messages = records.map((record, index) => [
+            `📋 记录 #${index + 1}`,
+            "--------------------------------",
+            `账号: ${record.accessUserName}`,
+            `记录类型: ${record.recordType}`,
+            `设备名称: ${record.nickName}`,
+            `IP地址: ${record.ip}`,
+            `MAC地址: ${record.mac}`,
+            `登录时间: ${record.userLoginInTime}`,
+            `登出时间: ${record.userLoginOutTime}`,
+            `原因: ${record.reason || "无"}`
+          ].join("\n"));
+          let result = messages.join("\n\n");
+          result += "\n--------------------------------";
+          return result;
+        } catch (error) {
+          console.error("查询过程出错:", error);
+          return error.message || "查询失败，请稍后重试";
         }
-        throw new Error("不支持的日期格式");
-      }, "parseDate");
-      let queryStartTime;
-      let queryEndTime;
-      try {
-        if (startTime && endTime) {
-          queryStartTime = formatDate(parseDate(startTime));
-          queryEndTime = formatDate(parseDate(endTime));
-        } else if (startTime) {
-          const endDate = parseDate(startTime);
-          const startDate = new Date(endDate);
-          startDate.setDate(startDate.getDate() - 1);
-          queryStartTime = formatDate(startDate);
-          queryEndTime = formatDate(endDate);
-        } else {
-          const today = /* @__PURE__ */ new Date();
-          const yesterday = new Date(today);
-          yesterday.setDate(yesterday.getDate() - 1);
-          queryStartTime = formatDate(yesterday);
-          queryEndTime = formatDate(today);
+      });
+      resolve();
+    });
+  });
+  ctx.command("终端查询 <mac:string>", "查询终端基本信息").action(async ({ session }, mac) => {
+    if (!mac) return "请输入要查询的MAC地址";
+    return new Promise((resolve) => {
+      addToMessageQueue(session, async () => {
+        try {
+          const formattedMac = formatMacAddress(mac);
+          const onuList = await queryOnuList(formattedMac);
+          if (!onuList) {
+            return "未找到该MAC地址的设备信息";
+          }
+          const onuDetail = await queryOnuDetailInfo(onuList.id);
+          const vlanInfo = await queryOnuDetailVlanInfo(onuList.id);
+          const messages = [
+            "🖥️ 终端基本信息",
+            "--------------------------------",
+            `MAC地址: ${formattedMac}`,
+            `状态：${onuDetail.status === 1 ? "在线 ✅" : "不在线 ❌"}`,
+            `设备名称: `,
+            `${onuDetail.deviceName}`,
+            `发射光功率: ${onuDetail.onuSendPower === "设备不在线" ? "设备不在线" : onuDetail.onuSendPower + "dBm"}`,
+            `接收光功率: ${onuDetail.onuReceivePower === "设备不在线" ? "设备不在线" : onuDetail.onuReceivePower + "dBm"}${onuDetail.onuReceivePower !== "设备不在线" ? " " + evaluateOpticalPower(onuDetail.onuReceivePower) : ""}`,
+            "",
+            "⚙️ 业务配置信息",
+            "--------------------------------"
+          ];
+          vlanInfo.forEach((info) => {
+            messages.push(
+              `端口 ${info.LAN}:`,
+              `  端口VLAN: ${info.VLAN || "未配置"}`,
+              `  工单VLAN: ${info.actualVlan || "未配置"}`
+            );
+          });
+          messages.push("--------------------------------");
+          return messages.join("\n");
+        } catch (error) {
+          console.error("查询过程出错:", error);
+          return "查询失败，请稍后重试";
         }
-      } catch (error) {
-        return "日期格式错误，支持的格式：\n1. 2025.4.4 或 2025/4/4\n2. 4.7 或 4/7（自动补全当前年份）\n3. 四月五号\n4. 四月五日";
+      });
+      resolve();
+    });
+  });
+  ctx.command("终端详细查询 <mac:string>", "查询终端详细信息").action(async ({ session }, mac) => {
+    if (!mac) return "请输入要查询的MAC地址";
+    return new Promise((resolve) => {
+      addToMessageQueue(session, async () => {
+        try {
+          const formattedMac = formatMacAddress(mac);
+          const onuList = await queryOnuList(formattedMac);
+          if (!onuList) {
+            return "未找到该MAC地址的设备信息";
+          }
+          const onuDetail = await queryOnuDetailInfo(onuList.id);
+          const ccname = await queryCCName(formattedMac);
+          const order = await queryOnuOrder(onuDetail);
+          const vlanInfo = await queryOnuDetailVlanInfo(onuList.id);
+          const messages = [
+            "🖥️ 终端基本信息",
+            "--------------------------------",
+            `MAC地址: ${formattedMac}`,
+            `状态：${onuDetail.status === 1 ? "在线 ✅" : "不在线 ❌"}`,
+            `机房: ${onuDetail.roomName}`,
+            `设备名称: `,
+            `${onuDetail.deviceName}`,
+            `OLT IP: ${onuDetail.oltIp}`,
+            `PON端口: ${onuDetail.portName}`,
+            `端口逻辑号: ${onuDetail.logicId}`,
+            `发射光功率: ${onuDetail.onuSendPower === "设备不在线" ? "设备不在线" : onuDetail.onuSendPower + "dBm"}`,
+            `接收光功率: ${onuDetail.onuReceivePower === "设备不在线" ? "设备不在线" : onuDetail.onuReceivePower + "dBm"}${onuDetail.onuReceivePower !== "设备不在线" ? " " + evaluateOpticalPower(onuDetail.onuReceivePower) : ""}`,
+            `CCName: ${ccname}`,
+            "",
+            "📃 工单信息",
+            "--------------------------------",
+            order ? [
+              `工单编号: ${order.orderId}`,
+              `创建时间: ${order.createDate}`,
+              `更新时间: ${order.updateDate}`
+            ].join("\n") : "无工单信息",
+            "",
+            "⚙️ 业务配置信息",
+            "--------------------------------"
+          ];
+          vlanInfo.forEach((info) => {
+            messages.push(
+              `端口 ${info.LAN}:`,
+              `  端口VLAN: ${info.VLAN || "未配置"}`,
+              `  工单VLAN: ${info.actualVlan || "未配置"}`
+            );
+          });
+          messages.push("--------------------------------");
+          return messages.join("\n");
+        } catch (error) {
+          console.error("查询过程出错:", error);
+          return "查询失败，请稍后重试";
+        }
+      });
+      resolve();
+    });
+  });
+  ctx.command("日志查询 <mac:string> [startTime:string] [endTime:string]", "查询终端工单日志").action(async ({ session }, mac, startTime, endTime) => {
+    if (!mac) return "请输入要查询的MAC地址";
+    try {
+      await session?.send("正在查询日志，请稍候...");
+      const formattedMac = formatMacAddress(mac);
+      const { formattedStartTime, formattedEndTime } = processTimeRange(startTime, endTime);
+      const token = await getToken();
+      const fetchLogsPromise = queryOrderLog(formattedMac, formattedStartTime, formattedEndTime, token);
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("查询超时，请稍后重试或缩短查询时间范围")), 3e4);
+      });
+      const logs = await Promise.race([fetchLogsPromise, timeoutPromise]).catch((error) => {
+        console.error("日志查询超时或出错:", error);
+        session?.send("日志查询耗时较长，结果将稍后发送。如长时间未收到，请重试或缩短查询范围");
+        return fetchLogsPromise.catch(() => []);
+      });
+      const filteredLogs = Array.isArray(logs) ? logs.filter((log) => log.title && log.title.includes("上线分析")) : [];
+      if (!filteredLogs || filteredLogs.length === 0) {
+        return "未找到该MAC地址的上线分析日志";
       }
-      const logs = await queryOrderLog(mac, queryStartTime, queryEndTime);
-      if (logs.length === 0) {
-        return `未找到${queryStartTime}到${queryEndTime}的上线分析日志`;
+      const MAX_LOGS_PER_MESSAGE = 5;
+      const totalBatches = Math.ceil(filteredLogs.length / MAX_LOGS_PER_MESSAGE);
+      if (filteredLogs.length > MAX_LOGS_PER_MESSAGE) {
+        await session?.send(formatOutputMessage(`共找到 ${filteredLogs.length} 条上线分析日志，将分${totalBatches}批发送`));
       }
-      const messages = [
-        "📋 工单日志",
-        "--------------------------------"
-      ];
-      logs.forEach((log) => {
-        if (log.title.includes("上线分析")) {
+      for (let i = 0; i < totalBatches; i++) {
+        const startIdx = i * MAX_LOGS_PER_MESSAGE;
+        const endIdx = Math.min(startIdx + MAX_LOGS_PER_MESSAGE, filteredLogs.length);
+        const batchLogs = filteredLogs.slice(startIdx, endIdx);
+        const messages = [
+          `📝 上线分析日志 (第 ${i + 1}/${totalBatches} 批)`,
+          "--------------------------------"
+        ];
+        batchLogs.forEach((log, index) => {
           messages.push(
-            `时间: ${log.updateDate}`,
-            `标题: ${log.title}`
+            `📄 日志 #${startIdx + index + 1}`,
+            `标题: ${log.title || "无标题"}`,
+            `描述: ${log.description || "无描述"}`,
+            `创建时间: ${log.createTime || "未知"}`,
+            `更新时间: ${log.updateTime || "未知"}`,
+            "--------------------------------"
           );
-          log.logs.forEach((logGroup) => {
-            logGroup.forEach((logLine) => {
-              if (logLine.startsWith("1.") && logLine.includes("Pon端TrunkAll检查结果是:") || logLine.startsWith("2.") && logLine.includes("查询ccname=")) {
-                messages.push(`  ${logLine}`);
-              }
-            });
-          });
+        });
+        if (!messages[messages.length - 1].includes("----")) {
           messages.push("--------------------------------");
         }
-      });
-      if (messages.length === 2) {
-        return `未找到${queryStartTime}到${queryEndTime}的上线分析日志`;
+        await session?.send(formatOutputMessage(messages.join("\n")));
+        if (i < totalBatches - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
       }
-      return messages.join("\n");
+      return;
     } catch (error) {
       console.error("查询过程出错:", error);
       return "查询失败，请稍后重试";
     }
   });
+  ctx.command("用户查询 <account:string>", "查询RADIUS用户信息").action(async ({ session }, account) => {
+    if (!account) return "请输入要查询的账号";
+    return new Promise((resolve) => {
+      addToMessageQueue(session, async () => {
+        try {
+          const radiusUserInfo = await queryRadiusUser(account);
+          if (radiusUserInfo.code !== "000000" || !radiusUserInfo.data) {
+            return `查询失败: ${radiusUserInfo.message || "未知错误"}`;
+          }
+          const { user, orders } = radiusUserInfo.data;
+          const messages = [
+            "🔐 RADIUS用户信息",
+            "--------------------------------",
+            `账号: ${user.login_name}`,
+            `密码: ${user.password}`,
+            `状态: ${translateUserStatus(user.user_status)} ${user.user_status === "active" ? "✅" : user.user_status === "suspend" ? "⚠️" : "❌"}`,
+            `漫游状态: ${user.roam_status === "0" ? "允许漫游" : "禁止漫游"}`,
+            `分公司标识: ${user.org_code}`,
+            `BOSS分公司标识: ${user.boss_org_code}`,
+            `用户VLAN: ${user.user_vlan}`,
+            "",
+            "🛒 订购信息",
+            "--------------------------------"
+          ];
+          if (orders && orders.length > 0) {
+            orders.forEach((order, index) => {
+              messages.push(
+                `订购 #${index + 1}:`,
+                `  订购状态: ${translateOrderStatus(order.order_status)}`,
+                `  服务名称: ${order.service_name}`,
+                `  生效时间: ${formatRadiusTime(order.valid_date)}`,
+                `  失效时间: ${formatRadiusTime(order.expire_date)}`
+              );
+              if (index < orders.length - 1) {
+                messages.push("");
+              }
+            });
+          } else {
+            messages.push("无订购信息");
+          }
+          messages.push("--------------------------------");
+          return messages.join("\n");
+        } catch (error) {
+          console.error("查询过程出错:", error);
+          return error.message || "查询失败，请稍后重试";
+        }
+      });
+      resolve();
+    });
+  });
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-jscn-aaaquery",
   "description": "江苏有线无锡分公司宽带信息查询插件",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -2,38 +2,54 @@
 
 [![npm](https://img.shields.io/npm/v/koishi-plugin-jscn-aaaquery?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-jscn-aaaquery)
 
-宽带账号认证查询插件
+江苏有线运维系统和RADIUS系统查询插件
 
-# Koishi 运维查询插件
+## 功能概述
 
-本插件提供了运维系统查询功能，包括账号查询、终端查询、日志查询等功能。
+本插件提供了江苏有线运维系统和RADIUS系统的查询功能，包括账号查询、终端查询、日志查询和用户查询等功能。支持智能识别输入内容自动选择查询类型。
 
-## 功能说明
+## 命令列表
 
 ### 1. 账号查询
 - 命令格式：`账号查询 <账号>`
 - 示例：`账号查询 GDC8510019239048`
 - 功能：查询宽带账号的基本信息，包括在线状态、IP地址、MAC地址等。
+- 返回信息：
+  - RADIUS用户信息：状态、密码等
+  - 账号基本信息：在线状态、认证状态、IP地址、MAC地址等
+  - 订购信息：订购状态、服务名称、生效时间、失效时间等
+- 备注：账号会自动转换为大写，在线时长会以"天小时分钟"的形式显示。
 
 ### 2. 账号详情
 - 命令格式：`账号详情 <账号>`
 - 示例：`账号详情 GDC8510019239048`
 - 功能：查询宽带账号的详细记录，包括登录时间、登出时间等。
+- 备注：账号会自动转换为大写。
 
 ### 3. 终端查询
 - 命令格式：`终端查询 <MAC地址>`
 - 示例：`终端查询 00:11:22:33:44:55`
 - 功能：查询终端的基本信息，包括光功率和业务配置信息。
+- 返回信息：
+  - 设备基本信息：状态、设备名称等
+  - 光功率信息：发射光功率、接收光功率（包含正常/过高/过低评估）
+  - 业务配置信息：端口VLAN和工单VLAN
 - MAC地址支持多种格式：
   - 纯字符串：`001122334455`
   - 冒号分隔：`00:11:22:33:44:55`
   - 短横线分隔：`00-11-22-33-44-55`
   - 点号分隔：`00.11.22.33.44.55`
+  - 中文符号分隔：`00：11。22-33｜44：55`
 
 ### 4. 终端详细查询
 - 命令格式：`终端详细查询 <MAC地址>`
 - 示例：`终端详细查询 00:11:22:33:44:55`
 - 功能：查询终端的详细信息，包括机房、设备名称、OLT IP、工单信息等。
+- 返回信息：
+  - 设备详细信息：状态、机房、设备名称、OLT IP、PON端口、逻辑号等
+  - 光功率信息：发射光功率、接收光功率（包含正常/过高/过低评估）
+  - 工单信息：工单编号、创建时间、更新时间
+  - 业务配置信息：端口VLAN和工单VLAN配置详情
 
 ### 5. 日志查询
 - 命令格式：`日志查询 <MAC地址> [开始时间] [结束时间]`
@@ -41,20 +57,88 @@
   - `日志查询 00:11:22:33:44:55`
   - `日志查询 00:11:22:33:44:55 2024.3.1 2024.3.10`
   - `日志查询 00:11:22:33:44:55 三月一日`
-- 功能：查询终端的工单日志。
+- 功能：查询终端的上线分析日志。
 - 时间格式支持：
   - 完整日期：`2024.3.1` 或 `2024/3/1`
   - 简写日期：`3.1` 或 `3/1`（自动补全当前年份）
   - 中文日期：`三月一日` 或 `三月一号`
 
-### 6. 智能查询
+### 6. 用户查询
+- 命令格式：`用户查询 <账号>`
+- 示例：`用户查询 GDC8510013590471`
+- 功能：查询RADIUS系统中的用户信息和订购状态。
+- 返回信息：
+  - 用户基本信息：账号、密码、状态、漫游设置等
+  - 订购信息：订购状态、服务名称、生效时间、失效时间等
+
+### 7. 智能查询
 - 直接输入MAC地址或账号即可查询，无需输入命令。
 - 示例：
   - `00:11:22:33:44:55`（自动识别为MAC地址并查询终端详情）
   - `GDC8510019239048`（自动识别为账号并查询账号信息）
+- 支持@机器人后发送查询内容
+
+## 插件配置
+
+### 必需配置项
+- `loginName`：运维系统登录账号
+- `password`：运维系统登录密码
+- `baseUrl`：运维系统API地址（默认：`http://172.16.251.75:8090/nms/api`）
+
+### 可选配置项
+- `radiusApiUrl`：RADIUS API基础URL（默认：`http://111.208.114.248:28210/api/radius`）
+
+## 性能优化
+
+插件内置了以下优化机制：
+1. **缓存机制**：缓存查询结果，减少重复请求（缓存时间默认5分钟）
+2. **令牌管理**：自动处理登录令牌的获取和刷新
+3. **请求队列**：防止相同请求重复发送，降低服务器负载
+4. **并发控制**：限制最大并发请求数，防止请求过多导致系统不稳定
+5. **消息队列**：使用消息处理队列，确保在高并发下消息不丢失
+6. **光功率评估**：自动评估接收光功率是否在正常范围内（-24dBm ~ -8dBm）
+7. **超时处理**：设置请求超时，自动处理长时间未响应的请求
+8. **格式优化**：优化消息显示格式，使用直观的图标显示状态信息
+9. **错误处理**：完善的错误处理机制，确保查询失败时有清晰的提示
+
+## 显示优化
+
+1. **状态指示**：
+   - 在线/正常状态：✅
+   - 离线/错误状态：❌
+   - 警告状态：⚠️
+
+2. **光功率评估**：
+   - 正常范围(-24dBm ~ -8dBm)：🟢正常
+   - 光功率过高(> -8dBm)：🔴过高
+   - 光功率过低(< -24dBm)：🔴过低
+
+3. **时间格式**：
+   - 在线时长显示为"天小时分钟"形式，例如"2天3小时15分钟"
+
+4. **消息格式**：
+   - 丰富的图标使信息更加直观
+   - 分级显示使信息层次清晰
+   - 内容丰富的查询结果使用新行显示
+   - 简短提示直接显示在同一行
 
 ## 注意事项
 1. 所有查询都需要正确的权限和配置。
-2. MAC地址不区分大小写，支持多种分隔符格式。
-3. 日期格式支持多种写法，但建议使用标准格式。
-4. 如果查询失败，请检查输入格式是否正确。
+2. MAC地址不区分大小写，支持多种分隔符格式，包括中文符号。
+3. 账号查询时会自动转换为大写。
+4. 日期格式支持多种写法，但建议使用标准格式。
+5. 如果查询失败，请检查输入格式是否正确。
+6. 确保运维系统和RADIUS系统API能够正常访问。
+7. 账号查询时会先检查RADIUS授权，如授权有误将不继续查询账号信息。
+
+## 更新日志
+
+### 最新更新
+- 增加了光功率评估功能，直观显示接收光功率是否在正常范围内
+- 优化了在线时长显示，支持天/小时/分钟格式
+- 增强了MAC地址格式处理，支持中文符号分隔
+- 添加了状态指示图标，使查询结果更加直观
+- 优化了消息格式，内容丰富的查询使用新行显示
+- 增加了RADIUS用户查询前置验证
+- 无论设备在线状态如何，都会尝试刷新光功率信息
+- 增强了高并发下的消息处理能力