koishi-plugin-jscn-aaaquery 1.0.1 → 1.0.3

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,13 +28,106 @@ 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 apply(ctx, config) {
   let currentToken = null;
   let tokenExpireTime = 0;
+  const requestQueue = {};
+  const cache = {};
+  const CACHE_EXPIRE_TIME = 5 * 60 * 1e3;
+  const CACHE_CLEAN_INTERVAL = 60 * 1e3;
+  const QUEUE_EXPIRE_TIME = 10 * 60 * 1e3;
+  const QUEUE_CLEAN_INTERVAL = 5 * 60 * 1e3;
+  const MAX_CONCURRENT_REQUESTS = 10;
+  let currentConcurrentRequests = 0;
+  const requestWaitQueue = [];
+  function getCacheKey(type, params) {
+    return `${type}:${JSON.stringify(params)}`;
+  }
+  __name(getCacheKey, "getCacheKey");
+  function getFromCache(type, params) {
+    const key = getCacheKey(type, params);
+    const item = cache[key];
+    if (item && Date.now() - item.timestamp <= CACHE_EXPIRE_TIME) {
+      return item.data;
+    }
+    return null;
+  }
+  __name(getFromCache, "getFromCache");
+  function setCache(type, params, data) {
+    const key = getCacheKey(type, params);
+    cache[key] = {
+      data,
+      timestamp: Date.now()
+    };
+  }
+  __name(setCache, "setCache");
+  setInterval(() => {
+    const now = Date.now();
+    for (const key in cache) {
+      if (now - cache[key].timestamp > CACHE_EXPIRE_TIME) {
+        delete cache[key];
+      }
+    }
+  }, CACHE_CLEAN_INTERVAL);
+  setInterval(() => {
+    const now = Date.now();
+    for (const key in requestQueue) {
+      if (now - requestQueue[key].timestamp > QUEUE_EXPIRE_TIME) {
+        delete requestQueue[key];
+      }
+    }
+  }, QUEUE_CLEAN_INTERVAL);
+  function getQueueKey(type, params) {
+    return `${type}:${JSON.stringify(params)}`;
+  }
+  __name(getQueueKey, "getQueueKey");
+  async function waitForRequestSlot() {
+    if (currentConcurrentRequests < MAX_CONCURRENT_REQUESTS) {
+      currentConcurrentRequests++;
+      return;
+    }
+    return new Promise((resolve) => {
+      requestWaitQueue.push(() => {
+        currentConcurrentRequests++;
+        resolve();
+      });
+    });
+  }
+  __name(waitForRequestSlot, "waitForRequestSlot");
+  function releaseRequestSlot() {
+    currentConcurrentRequests--;
+    if (requestWaitQueue.length > 0) {
+      const nextRequest = requestWaitQueue.shift();
+      if (nextRequest) {
+        nextRequest();
+      }
+    }
+  }
+  __name(releaseRequestSlot, "releaseRequestSlot");
+  async function addToQueue(type, params, fn) {
+    const key = getQueueKey(type, params);
+    if (requestQueue[key]) {
+      return requestQueue[key].promise;
+    }
+    await waitForRequestSlot();
+    const promise = fn();
+    requestQueue[key] = {
+      promise,
+      timestamp: Date.now()
+    };
+    promise.finally(() => {
+      delete requestQueue[key];
+      releaseRequestSlot();
+    });
+    return promise;
+  }
+  __name(addToQueue, "addToQueue");
   function formatMacAddress(mac) {
     return mac.replace(/[:-\s.]/g, "").toLowerCase();
   }
@@ -44,6 +137,14 @@ function apply(ctx, config) {
     return /^[0-9a-f]{12}$/i.test(cleanMac);
   }
   __name(isValidMacAddress, "isValidMacAddress");
+  function formatAccount(account) {
+    return account.toUpperCase();
+  }
+  __name(formatAccount, "formatAccount");
+  function isAccountResponseComplete(data) {
+    return !!(data.accessUserName && data.onlineStatus && data.isPass && data.userIp && data.mac && data.maxUpSpeed !== void 0 && data.maxDownSpeed !== void 0 && data.accessDomain && data.startTime && data.startTimeSum !== void 0 && data.nickName);
+  }
+  __name(isAccountResponseComplete, "isAccountResponseComplete");
   async function getToken() {
     const now = Date.now();
     if (currentToken && now < tokenExpireTime) {
@@ -52,10 +153,7 @@ function apply(ctx, config) {
     }
     try {
       console.log("开始登录请求...");
-      console.log("请求参数:", {
-        loginName: config.loginName,
-        pwd: config.password
-      });
+      await waitForRequestSlot();
       const response = await ctx.http.post(
         `${config.baseUrl}/admin/login`,
         `loginName=${encodeURIComponent(config.loginName)}&pwd=${encodeURIComponent(config.password)}`,
@@ -80,41 +178,56 @@ function apply(ctx, config) {
         console.error("错误响应:", error.response.data);
       }
       throw error;
+    } finally {
+      releaseRequestSlot();
     }
   }
   __name(getToken, "getToken");
   async function queryAccount(account) {
-    try {
-      console.log("开始查询账号信息...");
-      const token = await getToken();
-      const response = await ctx.http.get(`${config.baseUrl}/fttx/aaa/aaaCertification`, {
-        params: { accessUserName: account },
-        headers: {
-          "Authorization": token,
-          "Accept": "application/json",
-          "Content-Type": "application/json"
+    const formattedAccount = formatAccount(account);
+    const cachedData = getFromCache("account", { account: formattedAccount });
+    if (cachedData) {
+      console.log("使用缓存的账号信息");
+      return cachedData;
+    }
+    return addToQueue("account", { account: formattedAccount }, async () => {
+      try {
+        console.log("开始查询账号信息...");
+        const token = await getToken();
+        const response = await ctx.http.get(`${config.baseUrl}/fttx/aaa/aaaCertification`, {
+          params: { accessUserName: formattedAccount },
+          headers: {
+            "Authorization": token,
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+          }
+        });
+        console.log("查询响应:", JSON.stringify(response, null, 2));
+        if (response.status === 200 && response.data) {
+          if (!isAccountResponseComplete(response.data)) {
+            throw new Error("账号信息有误，请检查账号是否正确");
+          }
+          setCache("account", { account: formattedAccount }, response.data);
+          return response.data;
         }
-      });
-      console.log("查询响应:", JSON.stringify(response, null, 2));
-      if (response.status === 200 && response.data) {
-        return response.data;
-      }
-      throw new Error(`查询失败：${response.message || "未知错误"}`);
-    } catch (error) {
-      console.error("查询错误详情:", error);
-      if (error.response) {
-        console.error("错误响应:", error.response.data);
+        throw new Error(`查询失败：${response.message || "未知错误"}`);
+      } catch (error) {
+        console.error("查询错误详情:", error);
+        if (error.response) {
+          console.error("错误响应:", error.response.data);
+        }
+        throw error;
       }
-      throw error;
-    }
+    });
   }
   __name(queryAccount, "queryAccount");
   async function queryAccountDetail(account) {
+    const formattedAccount = formatAccount(account);
     try {
       console.log("开始查询账号详情记录...");
       const token = await getToken();
       const response = await ctx.http.get(`${config.baseUrl}/fttx/aaa/getMoreRecord`, {
-        params: { accessUserName: account },
+        params: { accessUserName: formattedAccount },
         headers: {
           "Authorization": token,
           "Accept": "application/json",
@@ -136,266 +249,407 @@ function apply(ctx, config) {
   }
   __name(queryAccountDetail, "queryAccountDetail");
   async function queryOnuList(mac) {
-    try {
-      console.log("开始查询MAC设备信息...");
-      const token = await getToken();
-      const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/searchOnuList`, {
-        params: { mac, limit: 50, page: 1 },
-        // 增加limit以获取更多结果
-        headers: {
-          "Authorization": token,
-          "Accept": "application/json",
-          "Content-Type": "application/json"
+    const cachedData = getFromCache("onuList", { mac });
+    if (cachedData) {
+      console.log("使用缓存的设备信息");
+      return cachedData;
+    }
+    return addToQueue("onuList", { mac }, async () => {
+      try {
+        console.log("开始查询MAC设备信息...");
+        const token = await getToken();
+        const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/searchOnuList`, {
+          params: { mac, limit: 10, page: 1 },
+          headers: {
+            "Authorization": token,
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+          }
+        });
+        console.log("查询响应:", JSON.stringify(response, null, 2));
+        if (response.status === 200 && response.data && response.data.rows && response.data.rows.length > 0) {
+          const activeOnu = response.data.rows.find((row) => row.status === 1);
+          if (activeOnu) {
+            console.log("找到在线设备:", activeOnu);
+            setCache("onuList", { mac }, activeOnu);
+            return activeOnu;
+          }
+          const lastOnu = response.data.rows[response.data.rows.length - 1];
+          console.log("没有在线设备，返回最后一条记录:", lastOnu);
+          setCache("onuList", { mac }, lastOnu);
+          return lastOnu;
         }
-      });
-      console.log("查询响应:", JSON.stringify(response, null, 2));
-      if (response.status === 200 && response.data && response.data.rows && response.data.rows.length > 0) {
-        const activeOnu = response.data.rows.find((row) => row.status === 1);
-        if (activeOnu) {
-          console.log("找到在线设备:", activeOnu);
-          return activeOnu;
+        throw new Error(`查询失败：${response.message || "未找到设备信息"}`);
+      } catch (error) {
+        console.error("查询错误详情:", error);
+        if (error.response) {
+          console.error("错误响应:", error.response.data);
         }
-        const lastOnu = response.data.rows[response.data.rows.length - 1];
-        console.log("没有在线设备，返回最后一条记录:", lastOnu);
-        return lastOnu;
-      }
-      throw new Error(`查询失败：${response.message || "未找到设备信息"}`);
-    } catch (error) {
-      console.error("查询错误详情:", error);
-      if (error.response) {
-        console.error("错误响应:", error.response.data);
+        throw error;
       }
-      throw error;
-    }
+    });
   }
   __name(queryOnuList, "queryOnuList");
   async function queryOnuDetailInfo(onuId) {
-    try {
-      console.log("开始查询MAC详细信息...");
-      const token = await getToken();
-      const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/onuDetailInfo`, {
-        params: { onuId },
-        headers: {
-          "Authorization": token,
-          "Accept": "application/json",
-          "Content-Type": "application/json"
-        }
-      });
-      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"
+    const cachedData = getFromCache("onuDetail", { onuId });
+    if (cachedData) {
+      console.log("使用缓存的设备详细信息");
+      return cachedData;
+    }
+    return addToQueue("onuDetail", { onuId }, async () => {
+      try {
+        console.log("开始查询MAC详细信息...");
+        const token = await getToken();
+        const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/onuDetailInfo`, {
+          params: { onuId },
+          headers: {
+            "Authorization": token,
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+          }
+        });
+        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"
+                  }
                 }
+              );
+              if (powerResponse.status === 200 && powerResponse.data) {
+                console.log("光功率刷新成功:", powerResponse.data);
+                response.data.onuReceivePower = powerResponse.data.onuReceivePower;
+                response.data.onuSendPower = powerResponse.data.onuSendPower;
+                response.data.statusHealth = powerResponse.data.statusHealth;
               }
-            );
-            if (powerResponse.status === 200 && powerResponse.data) {
-              console.log("光功率刷新成功:", powerResponse.data);
-              response.data.onuReceivePower = powerResponse.data.onuReceivePower;
-              response.data.onuSendPower = powerResponse.data.onuSendPower;
-              response.data.statusHealth = powerResponse.data.statusHealth;
+            } catch (error) {
+              console.error("刷新光功率失败:", error);
             }
-          } catch (error) {
-            console.error("刷新光功率失败:", error);
           }
+          setCache("onuDetail", { onuId }, response.data);
+          return response.data;
         }
-        return response.data;
-      }
-      throw new Error(`查询失败：${response.message || "未知错误"}`);
-    } catch (error) {
-      console.error("查询错误详情:", error);
-      if (error.response) {
-        console.error("错误响应:", error.response.data);
+        throw new Error(`查询失败：${response.message || "未知错误"}`);
+      } catch (error) {
+        console.error("查询错误详情:", error);
+        if (error.response) {
+          console.error("错误响应:", error.response.data);
+        }
+        throw error;
       }
-      throw error;
-    }
+    });
   }
   __name(queryOnuDetailInfo, "queryOnuDetailInfo");
   async function queryCCName(mac) {
-    try {
-      console.log("开始查询CCNAME...");
-      const token = await getToken();
-      const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/getCCname`, {
-        params: { mac },
-        headers: {
-          "Authorization": token,
-          "Accept": "application/json",
-          "Content-Type": "application/json"
+    const cachedData = getFromCache("ccname", { mac });
+    if (cachedData) {
+      console.log("使用缓存的CCNAME");
+      return cachedData;
+    }
+    return addToQueue("ccname", { mac }, async () => {
+      try {
+        console.log("开始查询CCNAME...");
+        const token = await getToken();
+        const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/getCCname`, {
+          params: { mac },
+          headers: {
+            "Authorization": token,
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+          }
+        });
+        console.log("查询响应:", JSON.stringify(response, null, 2));
+        if (response.status === 200 && response.data && response.data.ccname) {
+          setCache("ccname", { mac }, response.data.ccname);
+          return response.data.ccname;
         }
-      });
-      console.log("查询响应:", JSON.stringify(response, null, 2));
-      if (response.status === 200 && response.data && response.data.ccname) {
-        return response.data.ccname;
+        return "无CCName";
+      } catch (error) {
+        console.error("查询错误详情:", error);
+        return "无CCName";
       }
-      return "无CCName";
-    } catch (error) {
-      console.error("查询错误详情:", error);
-      return "无CCName";
-    }
+    });
   }
   __name(queryCCName, "queryCCName");
   async function queryOnuOrder(onuDetail) {
-    try {
-      console.log("开始查询工单信息...");
-      const token = await getToken();
-      const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/onuOrderList`, {
-        params: {
-          cid: onuDetail.cid,
-          gponIndex: onuDetail.gponIndex,
-          onuIndex: onuDetail.onuIndex,
-          serial: onuDetail.serial
-        },
-        headers: {
-          "Authorization": token,
-          "Accept": "application/json",
-          "Content-Type": "application/json"
+    const cacheKey = {
+      cid: onuDetail.cid,
+      gponIndex: onuDetail.gponIndex,
+      onuIndex: onuDetail.onuIndex,
+      serial: onuDetail.serial
+    };
+    const cachedData = getFromCache("onuOrder", cacheKey);
+    if (cachedData) {
+      console.log("使用缓存的工单信息");
+      return cachedData;
+    }
+    return addToQueue("onuOrder", cacheKey, async () => {
+      try {
+        console.log("开始查询工单信息...");
+        const token = await getToken();
+        const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/onuOrderList`, {
+          params: {
+            cid: onuDetail.cid,
+            gponIndex: onuDetail.gponIndex,
+            onuIndex: onuDetail.onuIndex,
+            serial: onuDetail.serial
+          },
+          headers: {
+            "Authorization": token,
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+          }
+        });
+        console.log("查询响应:", JSON.stringify(response, null, 2));
+        if (response.status === 200 && response.data && response.data.length > 0) {
+          setCache("onuOrder", cacheKey, response.data[0]);
+          return response.data[0];
         }
-      });
-      console.log("查询响应:", JSON.stringify(response, null, 2));
-      if (response.status === 200 && response.data && response.data.length > 0) {
-        return response.data[0];
+        return null;
+      } catch (error) {
+        console.error("查询错误详情:", error);
+        return null;
       }
-      return null;
-    } catch (error) {
-      console.error("查询错误详情:", error);
-      return null;
-    }
+    });
   }
   __name(queryOnuOrder, "queryOnuOrder");
   async function queryOnuDetailVlanInfo(onuId) {
-    try {
-      console.log("开始查询业务配置信息...");
-      const token = await getToken();
-      const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/onuDetailVlanInfo`, {
-        params: { onuId },
-        headers: {
-          "Authorization": token,
-          "Accept": "application/json",
-          "Content-Type": "application/json"
-        }
-      });
-      console.log("查询响应:", JSON.stringify(response, null, 2));
-      return response;
-    } catch (error) {
-      console.error("查询错误详情:", error);
-      return [];
+    const cachedData = getFromCache("onuVlan", { onuId });
+    if (cachedData) {
+      console.log("使用缓存的业务配置信息");
+      return cachedData;
     }
+    return addToQueue("onuVlan", { onuId }, async () => {
+      try {
+        console.log("开始查询业务配置信息...");
+        const token = await getToken();
+        const response = await ctx.http.get(`${config.baseUrl}/fttx/onu/onuDetailVlanInfo`, {
+          params: { onuId },
+          headers: {
+            "Authorization": token,
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+          }
+        });
+        console.log("查询响应:", JSON.stringify(response, null, 2));
+        setCache("onuVlan", { onuId }, response);
+        return response;
+      } catch (error) {
+        console.error("查询错误详情:", error);
+        return [];
+      }
+    });
   }
   __name(queryOnuDetailVlanInfo, "queryOnuDetailVlanInfo");
   async function queryOrderLog(mac, startTime, endTime) {
-    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`, {
-        params: {
-          mac: formattedMac,
-          startTime,
-          endTime
-        },
-        headers: {
-          "Authorization": token,
-          "Accept": "application/json",
-          "Content-Type": "application/json"
-        }
-      });
-      console.log("查询响应:", JSON.stringify(response, null, 2));
-      return response;
-    } catch (error) {
-      console.error("查询错误详情:", error);
-      return [];
+    const cacheKey = { mac, startTime, endTime };
+    const cachedData = getFromCache("orderLog", cacheKey);
+    if (cachedData) {
+      console.log("使用缓存的工单日志");
+      return cachedData;
     }
-  }
-  __name(queryOrderLog, "queryOrderLog");
-  ctx.middleware(async (session, next) => {
-    const input = session.content.trim();
-    if (input.includes(" ") || /[\u4e00-\u9fa5]/.test(input)) {
-      return next();
-    }
-    const cleanInput = formatMacAddress(input);
-    console.log("处理后的内容:", cleanInput);
-    if (isValidMacAddress(cleanInput)) {
+    return addToQueue("orderLog", cacheKey, 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}`
-          );
+        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`, {
+          params: {
+            mac: formattedMac,
+            startTime,
+            endTime
+          },
+          headers: {
+            "Authorization": token,
+            "Accept": "application/json",
+            "Content-Type": "application/json"
+          }
         });
-        return messages.join("\n");
+        console.log("查询响应:", JSON.stringify(response, null, 2));
+        setCache("orderLog", cacheKey, response);
+        return response;
       } catch (error) {
-        console.error("查询过程出错:", error);
-        return "查询失败，请稍后重试";
+        console.error("查询错误详情:", error);
+        return [];
       }
-    } else {
+    });
+  }
+  __name(queryOrderLog, "queryOrderLog");
+  async function queryRadiusUser(account) {
+    const cachedData = getFromCache("radiusUser", { account });
+    if (cachedData) {
+      console.log("使用缓存的RADIUS用户信息");
+      return cachedData;
+    }
+    return addToQueue("radiusUser", { account }, async () => {
       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 "查询失败，请稍后重试";
+        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;
+    }
+  }
+  __name(translateOrderStatus, "translateOrderStatus");
+  function translateUserStatus(status) {
+    switch (status) {
+      case "active":
+        return "正常";
+      case "inactive":
+        return "停用";
+      case "suspend":
+        return "暂停";
+      default:
+        return status;
+    }
+  }
+  __name(translateUserStatus, "translateUserStatus");
+  ctx.middleware(async (session, next) => {
+    console.log("原始消息:", session.content);
+    const input = session.content.trim();
+    console.log("接收到消息:", input);
+    try {
+      if (input.includes(" ") || /[\u4e00-\u9fa5]/.test(input)) {
+        console.log("消息包含空格或中文，跳过智能查询");
+        return next();
+      }
+      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}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("查询MAC地址过程出错:", error);
+          return "查询失败，请稍后重试";
+        }
+      } else {
+        console.log("内容不是MAC地址，尝试作为账号查询");
+        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;
+        } catch (error) {
+          console.error("查询账号过程出错:", error);
+          console.log("账号查询失败，交给其他中间件处理");
+          return next();
+        }
+      }
+    } catch (error) {
+      console.error("智能查询过程出错:", error);
+      return next();
     }
   });
   ctx.command("账号查询 <account:string>", "查询宽带账号状态").action(async (_, account) => {
@@ -420,7 +674,7 @@ function apply(ctx, config) {
       return message;
     } catch (error) {
       console.error("查询过程出错:", error);
-      return "查询失败，请稍后重试";
+      return error.message || "查询失败，请检查账号是否正确";
     }
   });
   ctx.command("账号详情 <account:string>", "查询宽带账号详细记录").action(async (_, account) => {
@@ -445,7 +699,7 @@ function apply(ctx, config) {
       return messages.join("\n\n");
     } catch (error) {
       console.error("查询过程出错:", error);
-      return "查询失败，请稍后重试";
+      return error.message || "查询失败，请稍后重试";
     }
   });
   ctx.command("终端查询 <mac:string>", "查询终端基本信息").action(async (_, mac) => {
@@ -665,6 +919,50 @@ function apply(ctx, config) {
       return "查询失败，请稍后重试";
     }
   });
+  ctx.command("用户查询 <account:string>", "查询RADIUS用户信息").action(async (_, account) => {
+    if (!account) return "请输入要查询的账号";
+    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.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}:`,
+            `  订购序列号: ${order.order_id}`,
+            `  订购状态: ${translateOrderStatus(order.order_status)}`,
+            `  服务名称: ${order.service_name}`,
+            `  并发数: ${order.online_num}`,
+            `  生效时间: ${formatRadiusTime(order.valid_date)}`,
+            `  失效时间: ${formatRadiusTime(order.expire_date)}`,
+            ""
+          );
+        });
+      } else {
+        messages.push("无订购信息");
+      }
+      return messages.join("\n");
+    } catch (error) {
+      console.error("查询过程出错:", error);
+      return error.message || "查询失败，请稍后重试";
+    }
+  });
 }
 __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.1",
+  "version": "1.0.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [