0

src/api/yjbdc/queuedArticleController.js

@@ -0,0 +1,132 @@
+import { GenerateArticle } from './yjbdcController.js';
+import requestQueue, { userRequestMap } from './requestQueue.js';
+import { globalCache } from '../../util/GlobalCache.js';
+
+// 启动队列处理器
+requestQueue.startQueueProcessor(GenerateArticle);
+
+/**
+ * 队列化文章生成API
+ * 如果当前一分钟内的处理队列少于上限，则直接调用GenerateArticle同步生成
+ * 如果当前队列大于等于上限，则告知用户排队中，返回result:-2
+ * 对于同一个用户ID，在一分钟内，如果超过1次请求，直接返回-1，不处理请求
+ */
+export async function QueuedGenerateArticle(ctx) {
+  try {
+    // 检查请求参数
+    if (!ctx.query || !ctx.query.UserID) {
+      ctx.body = { errcode: 10001, result: "-1", message: "缺少必要参数 UserID" };
+      return;
+    }
+    
+    const userID = ctx.query.UserID;
+    
+    // 检查用户请求频率限制（一分钟内只允许一次请求）
+    if (!requestQueue.canUserRequest(userID)) {
+      console.log(`用户 ${userID} 请求频率过高，一分钟内只允许一次请求`);
+      ctx.body = { 
+        errcode: 10000, 
+        result: "-1", 
+        message: "请求频率过高，一分钟内只允许一次请求" 
+      };
+      return;
+    }
+    
+    // 检查是否可以立即处理请求
+    if (requestQueue.canProcessImmediately()) {
+      // 直接调用原始的GenerateArticle函数
+      console.log(`直接处理请求，无需排队，用户ID: ${userID}`);
+      await GenerateArticle(ctx);
+    } else {
+      // 获取当前队列状态
+      const queueStatus = requestQueue.getQueueStatus();
+      console.log(`请求加入队列，当前队列长度: ${queueStatus.queueLength}，用户ID: ${userID}`);
+      
+      // 将请求添加到队列
+      const result = requestQueue.addToQueue(ctx);
+      ctx.body = result;
+    }
+  } catch (error) {
+    console.error(`处理队列化请求时出错，用户ID: ${ctx.query?.UserID || 'unknown'}:`, error);
+    ctx.body = { errcode: 10002, result: "-1", message: "处理请求时出错" };
+  }
+}
+
+/**
+ * 获取队列状态信息
+ */
+export async function GetQueueStatus(ctx) {
+  ctx.body = {
+    errcode: 10000,
+    result: requestQueue.getQueueStatus()
+  };
+}
+
+/**
+ * 获取特定用户的请求状态
+ */
+export async function GetUserRequestStatus(ctx) {
+  try {
+    const userID = ctx.query.UserID;
+    
+    if (!userID) {
+      ctx.body = { errcode: 10001, result: "-1", message: "缺少必要参数 UserID" };
+      return;
+    }
+    
+    // 从缓存中获取用户请求状态
+    const url = `GenerateArticle?UserID=${userID}`;
+    const status = globalCache.get(url);
+    
+    // 检查用户是否在队列中
+    const queuePosition = requestQueue.findUserPosition(userID);
+    
+    // 检查用户请求频率限制状态
+    const now = Date.now();
+    const lastRequestTime = userRequestMap.get(userID);
+    let canRequestAgain = true;
+    let timeUntilNextRequest = 0;
+    
+    if (lastRequestTime) {
+      const elapsedTime = now - lastRequestTime;
+      if (elapsedTime < 60000) {
+        canRequestAgain = false;
+        timeUntilNextRequest = Math.ceil((60000 - elapsedTime) / 1000);
+      }
+    }
+    
+    ctx.body = {
+      errcode: 10000,
+      result: {
+        status: status === undefined ? "未找到请求" : status,
+        inQueue: queuePosition > -1,
+        queuePosition: queuePosition,
+        estimatedTimeSeconds: queuePosition > 0 ? queuePosition * 60 / requestQueue.QUEUE_CONFIG.MAX_REQUESTS_PER_MINUTE : 0,
+        canRequestAgain: canRequestAgain,
+        timeUntilNextRequest: timeUntilNextRequest // 秒数
+      }
+    };
+  } catch (error) {
+    console.error(`获取用户请求状态时出错，用户ID: ${ctx.query?.UserID || 'unknown'}:`, error);
+    ctx.body = { errcode: 10002, result: "-1", message: "获取请求状态时出错" };
+  }
+}
+
+/**
+ * 更新队列配置
+ */
+export async function UpdateQueueConfig(ctx) {
+  const params = ctx.request.body;
+  requestQueue.updateConfig({
+    maxRequestsPerMinute: params.maxRequestsPerMinute,
+    queueCheckInterval: params.queueCheckInterval
+  });
+  
+  ctx.body = {
+    errcode: 10000,
+    result: {
+      message: '队列配置已更新',
+      currentConfig: requestQueue.QUEUE_CONFIG
+    }
+  };
+}

src/api/yjbdc/requestQueue.js

@@ -0,0 +1,238 @@
+// 请求队列管理模块
+import { globalCache } from '../../util/GlobalCache.js';
+import config from '../../config/index.js';
+
+// 导出用户请求映射，供其他模块使用
+export const userRequestMap = new Map();
+
+// 队列配置
+const QUEUE_CONFIG = {
+  MAX_REQUESTS_PER_MINUTE: 50, // 每分钟最大请求数，可配置
+  QUEUE_CHECK_INTERVAL: 1000, // 队列检查间隔（毫秒）
+};
+
+// 请求队列
+const requestQueue = [];
+
+// 追踪当前分钟内已处理的请求数
+let requestsInCurrentMinute = 0;
+let lastMinuteReset = Date.now();
+
+// 用户请求记录映射，记录用户最近一次请求的时间戳
+// 已在上方导出，此处不再重复定义
+
+// 重置计数器
+function resetRequestCounter() {
+  const now = Date.now();
+  if (now - lastMinuteReset >= 60000) {
+    requestsInCurrentMinute = 0;
+    lastMinuteReset = now;
+    return true;
+  }
+  return false;
+}
+
+// 处理队列中的请求
+async function processQueue(generateArticleFunc) {
+  if (requestQueue.length === 0) return;
+  
+  // 检查是否需要重置计数器
+  resetRequestCounter();
+  
+  // 如果当前分钟内的请求数已达到上限，则等待下一次检查
+  if (requestsInCurrentMinute >= QUEUE_CONFIG.MAX_REQUESTS_PER_MINUTE) {
+    return;
+  }
+  
+  // 从队列中取出一个请求
+  const request = requestQueue.shift();
+  if (!request) return;
+  
+  // 增加当前分钟内的请求计数
+  requestsInCurrentMinute++;
+  
+  // 计算请求在队列中等待的时间
+  const waitTime = Date.now() - request.enqueuedAt;
+  console.log(`开始处理队列请求，用户ID: ${request.userID}，等待时间: ${waitTime}ms`);
+  
+  // 构建一个模拟的 ctx 对象，用于传递给 GenerateArticle 函数
+  const mockCtx = {
+    query: request.ctx.query,
+    request: request.ctx.request,
+    body: undefined, // 将由 GenerateArticle 函数设置
+    set: () => {}, // 空函数，因为我们不需要设置 HTTP 头
+    // 添加其他可能需要的属性...
+  };
+  
+  try {
+    // 执行生成文章的函数 - GenerateArticle 会自行设置缓存状态
+    const url = `GenerateArticle?UserID=${request.userID}`;
+    
+    // 执行生成文章的函数
+    await generateArticleFunc(mockCtx);
+    
+    // GenerateArticle 函数会自行处理缓存，所以这里不需要额外操作
+    console.log(`队列请求处理完成: ${url}，处理时间: ${Date.now() - request.enqueuedAt}ms`);
+  } catch (error) {
+    console.error(`队列处理请求时出错，用户ID: ${request.userID}:`, error);
+    
+    // 出错时设置错误状态到缓存
+    const url = `GenerateArticle?UserID=${request.userID}`;
+    const errorResult = { errcode: 10000, result: "-1", error: "处理请求时出错" };
+    globalCache.set(url, errorResult, config.BufferMemoryTime);
+  }
+}
+
+// 启动队列处理器
+let queueProcessorInterval = null;
+
+function startQueueProcessor(generateArticleFunc) {
+  if (queueProcessorInterval) return;
+  
+  // 保存函数引用以便重启时使用
+  generateArticleFuncRef = generateArticleFunc;
+  
+  queueProcessorInterval = setInterval(() => {
+    processQueue(generateArticleFunc);
+  }, QUEUE_CONFIG.QUEUE_CHECK_INTERVAL);
+  
+  console.log('队列处理器已启动');
+}
+
+// 停止队列处理器
+function stopQueueProcessor() {
+  if (queueProcessorInterval) {
+    clearInterval(queueProcessorInterval);
+    queueProcessorInterval = null;
+    console.log('队列处理器已停止');
+  }
+}
+
+// 添加请求到队列
+function addToQueue(ctx) {
+  // 深拷贝 ctx 对象的必要属性，避免引用问题
+  const ctxCopy = {
+    query: { ...ctx.query },
+    request: {
+      body: ctx.request.body ? JSON.parse(JSON.stringify(ctx.request.body)) : {}
+    },
+    // 添加一个响应处理函数，用于设置队列处理结果
+    setBody: (body) => {
+      // 这个函数在队列处理时不会被调用，仅作为占位符
+      console.log('队列处理完成，但无法直接返回结果给客户端');
+    }
+  };
+  
+  // 设置请求加入队列的时间戳，用于监控队列延迟
+  const queueItem = {
+    ctx: ctxCopy,
+    enqueuedAt: Date.now(),
+    userID: ctx.query.UserID
+  };
+  
+  requestQueue.push(queueItem);
+  console.log(`请求已添加到队列，当前队列长度: ${requestQueue.length}，用户ID: ${ctx.query.UserID}`);
+  
+  // 在缓存中标记该请求正在队列中处理
+  const url = `GenerateArticle?UserID=${ctx.query.UserID}`;
+  const queueStatus = { errcode: 10000, result: "-2", queuePosition: requestQueue.length, isQueued: true };
+  globalCache.set(url, queueStatus, config.BufferMemoryTime);
+  
+  return queueStatus; // 返回排队中的状态码和队列位置
+}
+
+// 检查是否可以立即处理请求
+function canProcessImmediately() {
+  resetRequestCounter();
+  return requestsInCurrentMinute < QUEUE_CONFIG.MAX_REQUESTS_PER_MINUTE;
+}
+
+// 获取队列状态信息
+function getQueueStatus() {
+  return {
+    queueLength: requestQueue.length,
+    requestsInCurrentMinute,
+    maxRequestsPerMinute: QUEUE_CONFIG.MAX_REQUESTS_PER_MINUTE,
+    timeUntilReset: Math.max(0, 60000 - (Date.now() - lastMinuteReset))
+  };
+}
+
+// 存储生成文章函数的引用
+let generateArticleFuncRef = null;
+
+// 更新配置
+function updateConfig(config) {
+  if (config.maxRequestsPerMinute) {
+    QUEUE_CONFIG.MAX_REQUESTS_PER_MINUTE = config.maxRequestsPerMinute;
+  }
+  if (config.queueCheckInterval) {
+    QUEUE_CONFIG.QUEUE_CHECK_INTERVAL = config.queueCheckInterval;
+    
+    // 重启队列处理器以应用新的检查间隔
+    if (queueProcessorInterval && generateArticleFuncRef) {
+      stopQueueProcessor();
+      startQueueProcessor(generateArticleFuncRef);
+    }
+  }
+}
+
+// 查找用户在队列中的位置
+function findUserPosition(userID) {
+  if (!userID) return -1;
+  
+  for (let i = 0; i < requestQueue.length; i++) {
+    if (requestQueue[i].userID === userID) {
+      return i;
+    }
+  }
+  
+  return -1;
+}
+
+// 检查用户是否可以发送请求（一分钟内只允许一次请求）
+function canUserRequest(userID) {
+  if (!userID) return false;
+  
+  const now = Date.now();
+  const lastRequestTime = userRequestMap.get(userID);
+  
+  // 如果用户没有请求记录，或者上次请求时间超过一分钟，则允许请求
+  if (!lastRequestTime || (now - lastRequestTime >= 60000)) {
+    // 更新用户最近一次请求时间
+    userRequestMap.set(userID, now);
+    return true;
+  }
+  
+  // 计算用户需要等待的时间（毫秒）
+  const waitTime = 60000 - (now - lastRequestTime);
+  console.log(`用户 ${userID} 请求过于频繁，需等待 ${Math.ceil(waitTime / 1000)} 秒`);
+  
+  return false;
+}
+
+// 清理过期的用户请求记录（可选，防止内存泄漏）
+function cleanupUserRequestMap() {
+  const now = Date.now();
+  const expireTime = 60000; // 一分钟过期
+  
+  userRequestMap.forEach((timestamp, userID) => {
+    if (now - timestamp >= expireTime) {
+      userRequestMap.delete(userID);
+    }
+  });
+}
+
+// 定期清理过期的用户请求记录
+setInterval(cleanupUserRequestMap, 60000);
+
+export default {
+  addToQueue,
+  canProcessImmediately,
+  startQueueProcessor,
+  stopQueueProcessor,
+  getQueueStatus,
+  updateConfig,
+  findUserPosition,
+  canUserRequest,
+  QUEUE_CONFIG
+};

src/api/yjbdc/routes.js

@@ -1,5 +1,6 @@
 import Router from 'koa-router';
 import * as yjbdcController from './yjbdcController.js';
+import * as queuedArticleController from './queuedArticleController.js';
 
 const router = new Router();
 
@@ -19,5 +20,10 @@ router.get('/api/GetWordChinese',yjbdcController.GetWordChinese);
 
 router.get('/yjbdc_article_admin',yjbdcController.YJBDC_Articles_Admin);
 
+// 队列化文章生成API
+router.post('/api/QueuedGenerateArticle', queuedArticleController.QueuedGenerateArticle);
+router.get('/api/GetQueueStatus', queuedArticleController.GetQueueStatus);
+router.get('/api/GetUserRequestStatus', queuedArticleController.GetUserRequestStatus);
+router.post('/api/UpdateQueueConfig', queuedArticleController.UpdateQueueConfig);
 
 export default router;

src/api/yjbdc/yjbdcController.js

@@ -15,172 +15,23 @@ import aiController from './aiController.js';
 
 import PDFDocument from 'pdfkit';
 import tencentcloud from 'tencentcloud-sdk-nodejs-ocr';
-
-const ONE_DAY_MAX_BUILD_COUNT=12;//一天最大生成数
-
 const OcrClient = tencentcloud.ocr.v20181119.Client;
+const ONE_DAY_MAX_BUILD_COUNT=12;//一天最大生成数
 
-//小程序登录
-export async function YJBDCLogin(ctx) {
-    let param = ctx.request.body;
-    if (param.param) {
-        const paramStr = Decrypt(param.param, config.urlSecrets.aes_key, config.urlSecrets.aes_iv);
-        //console.log("paramStr:"+paramStr);
-        param = JSON.parse(paramStr);
-    }
-    const code = param.Code;
-    //console.log("code:"+code);
-    const url = `https://api.weixin.qq.com/sns/jscode2session?appid=${config.wx.yjbdc_appid}&secret=${config.wx.yjbdc_appsecret}&js_code=${code}&grant_type=authorization_code`;
-
-    let result = await axios.get(url)
-        .then(res => {
-            const json = res.data;
-            //console.log("json:"+json);
-            if (json && json.openid) {
-                param.OpenID = json.openid;
-                param.sessionKey = json.session_key;
-                if (json.unionid)
-                    param.UnionID = json.unionid;
-                return {errcode: 10000};
-            }
-            else {
-                return json;
-            }
-        })
-        .catch(err => {
-            return {errcode: 101, errStr: err};
-        });
-
-    if (result.errcode == 10000) {
-        delete param.Code;
-        if (param.sessionKey && param.iv && param.encryptedData){
-            //console.log("param.sessionKey:"+param.sessionKey);
-            const pc = new WXBizDataCrypt(config.wx.yjbdc_appid, param.sessionKey);
-            const dataUnionID = pc.decryptData(param.encryptedData , param.iv);
-            //console.log(dataUnionID);
-            param.UnionID = dataUnionID.unionId;
-        }
-
-        delete param.sessionKey;
-        delete param.iv;
-        delete param.encryptedData;
-
-        //todo
-        //param.OpenID="o4UHq4gaNlHfdTWxgl3fTgC1mFsI";
-
-        let userList = await yjbdc.GetUsersInfo(param);
-        if (userList.length > 0) {
-            param.LastLoginTime = new Date();
-            const time1 = moment(userList[0].ProductServiceTime).format('YYYY-MM-DD HH:mm:ss');
-            const time3 = moment().format('YYYY-MM-DD HH:mm:ss');
-            if (time1 < time3)
-                param.IsMember = 0;
-
-            delete param.Introducer;
-            delete param.UserSource;
-            delete param.SourceID;
-            //console.log(param.NickName);
-            if (param.NickName == "陌生用户") {
-                delete param.NickName;
-                delete param.AvatarUrl;
-                delete param.Language;
-                delete param.Gender;
-                delete param.City;
-                delete param.Province;
-                delete param.Country;
-            }
-
-            await yjbdc.UpdateUsers(param);
-            userList = await yjbdc.GetUsersInfo(param);
-        }
-        else {
-            param.NickName = "陌生用户";
-            param.AvatarUrl = "../images/userface_default.png";
-            param.CreateTime = new Date();
-            param.LastLoginTime = param.CreateTime;
-            param.ProductServiceTime = param.CreateTime;
-            const inseredID = await yjbdc.AddUsers(param);
-            userList = await yjbdc.GetUsersInfo(param);
-        }
-
-        delete userList[0].OpenID;
-        delete userList[0].UnionID;
-
-        //产品支付是否显示
-        if (param.ProgramVersion) {
-            let param2 = {
-                ProgramID: 186,
-                Version: param.ProgramVersion,
-            };
-            let result3 = await commonModel.GetProductVersionList(param2);
-            if (result3) {
-                if ((param2.Version == result3[0].Version && result3[0].IsShowPay <= 0)
-                    || param2.Version > result3[0].Version) {
-                    userList[0].IsShow = result3[0].IsShowPay;
-                }
-                else {
-                    userList[0].IsShow = 1;
-                }
-
-                //针对iphone测试用户，永远是无支付状态
-                if (userList[0].Brand == 'iPhone' && userList[0].WXLanguage == 'en-US'
-                    && userList[0].UserSource == '1001' && userList[0].IsPay == 0) {
-                    userList[0].IsShow = 0;
-                }
-
-                //针对微信测试用户，永远是无支付状态
-                if ((userList[0].UserSource=='1001' && userList[0].System=="iOS 10.0.1")
-                    || (!userList[0].UserSource && (!userList[0].LastUserSource || userList[0].LastUserSource>10000))
-                    || userList[0].NickName.indexOf("dgztest")>=0){
-                    userList[0].IsShow=-1;
-                }
-
-                if (userList[0].IsMember===1)
-                    userList[0].IsShow=1;
-            }
-        }
-
-        result = {errcode: 10000, result: userList[0]};
-    }
-
-    ctx.body = result;
-}
-
-//OCR获取单词
-export async function OCRImageData(ctx) {
-    const params = ctx.request.body;
-    
-    const clientConfig = {
-        credential: {
-            secretId: config.tencentcloud.secretId,
-            secretKey: config.tencentcloud.secretKey,
-        },
-        region: "ap-guangzhou",
-        profile: {
-            httpProfile: {
-                endpoint: "ocr.tencentcloudapi.com",
-            },
-        },
-    };
-
-    // 实例化要请求产品的client对象,clientProfile是可选的
-    const client = new OcrClient(clientConfig);
-    const result = await client.GeneralBasicOCR(params);
 
-    let param2={};
-    param2.UserID=ctx.query.UserID;
-    param2.CreateTime=moment().format('YYYY-MM-DD HH:mm:ss');
-    param2.Params=JSON.stringify(params);
-    param2.JSONString=JSON.stringify(result);
-    await yjbdc.AddOCRInfo(param2);
-    ctx.body = {"errcode": 10000, result};
-}
 
 //AI生成文章
 export async function GenerateArticle(ctx) {
 
     const url='GenerateArticle?UserID='+ctx.query.UserID;
     let result = globalCache.get(url);
+
+    // 检查是否是队列状态而不是正在处理状态
+    if (result && result.isQueued) {
+        // 如果是队列状态，继续处理
+        result = 0;
+    } 
+
     if (result === 0) {
         const params = ctx.request.body;
         const words = params.Words;
@@ -361,6 +212,162 @@ export async function GenerateArticle(ctx) {
     ctx.body = result;
 }
 
+//小程序登录
+export async function YJBDCLogin(ctx) {
+    let param = ctx.request.body;
+    if (param.param) {
+        const paramStr = Decrypt(param.param, config.urlSecrets.aes_key, config.urlSecrets.aes_iv);
+        //console.log("paramStr:"+paramStr);
+        param = JSON.parse(paramStr);
+    }
+    const code = param.Code;
+    //console.log("code:"+code);
+    const url = `https://api.weixin.qq.com/sns/jscode2session?appid=${config.wx.yjbdc_appid}&secret=${config.wx.yjbdc_appsecret}&js_code=${code}&grant_type=authorization_code`;
+
+    let result = await axios.get(url)
+        .then(res => {
+            const json = res.data;
+            //console.log("json:"+json);
+            if (json && json.openid) {
+                param.OpenID = json.openid;
+                param.sessionKey = json.session_key;
+                if (json.unionid)
+                    param.UnionID = json.unionid;
+                return {errcode: 10000};
+            }
+            else {
+                return json;
+            }
+        })
+        .catch(err => {
+            return {errcode: 101, errStr: err};
+        });
+
+    if (result.errcode == 10000) {
+        delete param.Code;
+        if (param.sessionKey && param.iv && param.encryptedData){
+            //console.log("param.sessionKey:"+param.sessionKey);
+            const pc = new WXBizDataCrypt(config.wx.yjbdc_appid, param.sessionKey);
+            const dataUnionID = pc.decryptData(param.encryptedData , param.iv);
+            //console.log(dataUnionID);
+            param.UnionID = dataUnionID.unionId;
+        }
+
+        delete param.sessionKey;
+        delete param.iv;
+        delete param.encryptedData;
+
+        //todo
+        //param.OpenID="o4UHq4gaNlHfdTWxgl3fTgC1mFsI";
+
+        let userList = await yjbdc.GetUsersInfo(param);
+        if (userList.length > 0) {
+            param.LastLoginTime = new Date();
+            const time1 = moment(userList[0].ProductServiceTime).format('YYYY-MM-DD HH:mm:ss');
+            const time3 = moment().format('YYYY-MM-DD HH:mm:ss');
+            if (time1 < time3)
+                param.IsMember = 0;
+
+            delete param.Introducer;
+            delete param.UserSource;
+            delete param.SourceID;
+            //console.log(param.NickName);
+            if (param.NickName == "陌生用户") {
+                delete param.NickName;
+                delete param.AvatarUrl;
+                delete param.Language;
+                delete param.Gender;
+                delete param.City;
+                delete param.Province;
+                delete param.Country;
+            }
+
+            await yjbdc.UpdateUsers(param);
+            userList = await yjbdc.GetUsersInfo(param);
+        }
+        else {
+            param.NickName = "陌生用户";
+            param.AvatarUrl = "../images/userface_default.png";
+            param.CreateTime = new Date();
+            param.LastLoginTime = param.CreateTime;
+            param.ProductServiceTime = param.CreateTime;
+            const inseredID = await yjbdc.AddUsers(param);
+            userList = await yjbdc.GetUsersInfo(param);
+        }
+
+        delete userList[0].OpenID;
+        delete userList[0].UnionID;
+
+        //产品支付是否显示
+        if (param.ProgramVersion) {
+            let param2 = {
+                ProgramID: 186,
+                Version: param.ProgramVersion,
+            };
+            let result3 = await commonModel.GetProductVersionList(param2);
+            if (result3) {
+                if ((param2.Version == result3[0].Version && result3[0].IsShowPay <= 0)
+                    || param2.Version > result3[0].Version) {
+                    userList[0].IsShow = result3[0].IsShowPay;
+                }
+                else {
+                    userList[0].IsShow = 1;
+                }
+
+                //针对iphone测试用户，永远是无支付状态
+                if (userList[0].Brand == 'iPhone' && userList[0].WXLanguage == 'en-US'
+                    && userList[0].UserSource == '1001' && userList[0].IsPay == 0) {
+                    userList[0].IsShow = 0;
+                }
+
+                //针对微信测试用户，永远是无支付状态
+                if ((userList[0].UserSource=='1001' && userList[0].System=="iOS 10.0.1")
+                    || (!userList[0].UserSource && (!userList[0].LastUserSource || userList[0].LastUserSource>10000))
+                    || userList[0].NickName.indexOf("dgztest")>=0){
+                    userList[0].IsShow=-1;
+                }
+
+                if (userList[0].IsMember===1)
+                    userList[0].IsShow=1;
+            }
+        }
+
+        result = {errcode: 10000, result: userList[0]};
+    }
+
+    ctx.body = result;
+}
+
+//OCR获取单词
+export async function OCRImageData(ctx) {
+    const params = ctx.request.body;
+    
+    const clientConfig = {
+        credential: {
+            secretId: config.tencentcloud.secretId,
+            secretKey: config.tencentcloud.secretKey,
+        },
+        region: "ap-guangzhou",
+        profile: {
+            httpProfile: {
+                endpoint: "ocr.tencentcloudapi.com",
+            },
+        },
+    };
+
+    // 实例化要请求产品的client对象,clientProfile是可选的
+    const client = new OcrClient(clientConfig);
+    const result = await client.GeneralBasicOCR(params);
+
+    let param2={};
+    param2.UserID=ctx.query.UserID;
+    param2.CreateTime=moment().format('YYYY-MM-DD HH:mm:ss');
+    param2.Params=JSON.stringify(params);
+    param2.JSONString=JSON.stringify(result);
+    await yjbdc.AddOCRInfo(param2);
+    ctx.body = {"errcode": 10000, result};
+}
+
 export async function GetYJBDCGenerateConfig(ctx) {
     const param = {
         UserID: ctx.query.UserID || 0,

src/test/build.test.js

@@ -52,7 +52,7 @@ async function runScript(){
 
             //生成例句
             let result = await aiController.generateArticle(content, aiProvider);
-            //console.log(result); 
+            console.log(result); 
             let sql2="update Words set ExampleSentence=? where ID="+item.ID+";";
             await commonModel.RunSql(result,sql2);
             

test-aliyun-api.js

@@ -1,15 +0,0 @@
-// 测试阿里云通义千问API调用
-import { generateArticle } from './src/api/yjbdc/aiController.js';
-
-async function testAliyunAPI() {
-  try {
-    console.log('开始测试阿里云通义千问API...');
-    const result = await generateArticle('请简要介绍一下人工智能的发展历程', 'aliyun');
-    console.log('API调用成功，返回结果:');
-    console.log(result);
-  } catch (error) {
-    console.error('API调用失败:', error);
-  }
-}
-
-testAliyunAPI();

test-json-fix.js

@@ -1,61 +0,0 @@
-// 测试JSON修复功能
-import { validateAndFixJSON } from './src/api/yjbdc/aiController.js';
-
-// 测试用例
-const testCases = [
-  // 正常JSON
-  { 
-    name: "正常JSON", 
-    input: '{"name":"test","value":123}' 
-  },
-  // Markdown代码块包裹的JSON
-  { 
-    name: "Markdown代码块", 
-    input: '```json\n{"name":"test","value":123}\n```' 
-  },
-  // 带有语法错误的JSON
-  { 
-    name: "语法错误JSON", 
-    input: '{name:"test",value:123}' 
-  },
-  // 混合问题
-  { 
-    name: "混合问题", 
-    input: '```json\n{name:"test",value:123}\n```' 
-  },
-  // 非JSON内容中包含JSON对象
-  {
-    name: "非JSON内容中包含JSON对象",
-    input: '这是一段文本，其中包含JSON：{"name":"test","value":123}，后面还有其他内容'
-  },
-  // 阿里云通义千问可能返回的格式
-  {
-    name: "阿里云通义千问返回格式",
-    input: '```json\n{\n  "title": "测试文章",\n  "content": "这是一篇测试文章",\n  "author": "AI助手",\n  "date": "2023-07-15"\n}\n```'
-  }
-];
-
-// 运行测试
-console.log("开始测试JSON修复功能...\n");
-
-testCases.forEach(testCase => {
-  console.log(`测试用例: ${testCase.name}`);
-  console.log(`输入: ${testCase.input}`);
-  
-  try {
-    const fixed = validateAndFixJSON(testCase.input);
-    console.log(`修复后: ${fixed}`);
-    
-    try {
-      const parsed = JSON.parse(fixed);
-      console.log(`解析结果: ${JSON.stringify(parsed, null, 2)}`);
-      console.log("✅ 测试通过\n");
-    } catch (error) {
-      console.error(`❌ 修复后仍无法解析: ${error.message}\n`);
-    }
-  } catch (error) {
-    console.error(`❌ 修复过程出错: ${error.message}\n`);
-  }
-});
-
-console.log("测试完成");