0

src/api/yjbdc/aiController.js

@@ -0,0 +1,369 @@
+import axios from 'axios';
+import config from '../../config/index.js';
+
+/**
+ * AI平台接口类
+ * 定义了所有AI平台需要实现的方法
+ */
+class AIProvider {
+    /**
+     * 生成文章
+     * @param {string} content - 生成文章的提示内容
+     * @returns {Promise<string>} - 返回生成的文章JSON字符串
+     */
+    async generateArticle(content) {
+        throw new Error('Method not implemented');
+    }
+}
+
+/**
+ * 火山云AI平台实现
+ */
+class VolcesAIProvider extends AIProvider {
+    /**
+     * 创建火山云AI提供者实例
+     * @param {string} version - 版本号，如'1.5'或'1.6'
+     */
+    constructor(version = '1-5') {
+        super();
+        
+        // 根据版本选择对应的API密钥和模型
+        const versionConfig = {
+            '1-5': {
+                apikey: config.huoshancloud.apikeyHLR,
+                model: "doubao-1-5-pro-32k-250115"
+            },
+            '1-6': {
+                apikey: config.huoshancloud.apikeyHLR,
+                model: "doubao-seed-1-6-250615"
+            },
+        };
+        
+        // 获取当前版本的配置，如果版本不存在则使用1.5版本
+        const currentConfig = versionConfig[version] || versionConfig['1-5'];
+        
+        this.version = version;
+        this.headers = {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.65 Safari/537.36',
+            "Authorization": "Bearer " + currentConfig.apikey,
+            "Content-Type": "application/json"
+        };
+        this.url = "https://ark.cn-beijing.volces.com/api/v3/chat/completions";
+        this.model = currentConfig.model;
+    }
+
+    async generateArticle(content) {
+        const postJSON = {
+            "model": this.model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": content,
+                }
+            ]
+        };
+
+        try {
+            console.log(`火山云${this.version}`);
+            const response = await axios.post(encodeURI(this.url), postJSON, { headers: this.headers });
+            return response.data.choices[0].message.content;
+        } catch (error) {
+            console.error("VolcesAI API error:", error);
+            throw error;
+        }
+    }
+}
+
+// 为了保持向后兼容性，创建1.5和1.6版本的类别名
+class VolcesAIProvider1_5 extends VolcesAIProvider {
+    constructor() {
+        super('1-5');
+    }
+}
+
+class VolcesAIProvider1_6 extends VolcesAIProvider {
+    constructor() {
+        super('1-6');
+    }
+}
+
+/**
+ * OpenAI平台实现
+ */
+class OpenAIProvider extends AIProvider {
+    constructor() {
+        super();
+        this.headers = {
+            "Authorization": "Bearer " + config.openai.apikey,
+            "Content-Type": "application/json"
+        };
+        this.url = "https://api.openai.com/v1/chat/completions";
+        this.model = "gpt-3.5-turbo";
+    }
+
+    async generateArticle(content) {
+        const postJSON = {
+            "model": this.model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": content,
+                }
+            ]
+        };
+
+        try {
+            const response = await axios.post(this.url, postJSON, { headers: this.headers });
+            return response.data.choices[0].message.content;
+        } catch (error) {
+            console.error("OpenAI API error:", error);
+            throw error;
+        }
+    }
+}
+
+/**
+ * 百度文心一言平台实现
+ */
+class BaiduAIProvider extends AIProvider {
+    constructor() {
+        super();
+        this.headers = {
+            "Content-Type": "application/json"
+        };
+        this.url = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions";
+        this.model = "ernie-bot-4";
+        this.accessToken = null;
+    }
+
+    async getAccessToken() {
+        if (this.accessToken) return this.accessToken;
+        
+        const tokenUrl = `https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=${config.baidu.apiKey}&client_secret=${config.baidu.secretKey}`;
+        
+        try {
+            const response = await axios.post(tokenUrl);
+            this.accessToken = response.data.access_token;
+            return this.accessToken;
+        } catch (error) {
+            console.error("Baidu access token error:", error);
+            throw error;
+        }
+    }
+
+    async generateArticle(content) {
+        const accessToken = await this.getAccessToken();
+        const apiUrl = `${this.url}?access_token=${accessToken}`;
+        
+        const postJSON = {
+            "model": this.model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": content,
+                }
+            ]
+        };
+
+        try {
+            const response = await axios.post(apiUrl, postJSON, { headers: this.headers });
+            return response.data.result;
+        } catch (error) {
+            console.error("Baidu AI API error:", error);
+            throw error;
+        }
+    }
+}
+
+/**
+ * AI提供者工厂类
+ * 根据配置创建不同的AI平台实例
+ */
+class AIProviderFactory {
+    /**
+     * 获取AI提供者实例
+     * @param {string} provider - AI提供者名称，如'volces', 'volces1-5', 'volces1-6', 'openai', 'baidu'
+     * @returns {AIProvider} - 返回对应的AI提供者实例
+     */
+    static getProvider(provider = 'volces1-5') {
+        const providerLower = provider.toLowerCase();
+        
+        // 处理火山云通用提供者格式：volces:版本号
+        if (providerLower.startsWith('volces:')) {
+            const version = providerLower.split(':')[1];
+            return new VolcesAIProvider(version);
+        }
+        
+        // 处理传统提供者名称
+        switch (providerLower) {
+            case 'volces':
+            case 'volces1-5':
+                return new VolcesAIProvider1_5('1-5');
+            case 'volces1-6':
+                return new VolcesAIProvider1_6('1-6');
+            case 'openai':
+                return new OpenAIProvider();
+            case 'baidu':
+                return new BaiduAIProvider();
+            default:
+                return new VolcesAIProvider('1-5'); // 默认使用火山云1.5
+        }
+    }
+}
+
+/**
+ * 生成文章的主函数
+ * @param {string} content - 生成文章的提示内容
+ * @param {string} provider - AI提供者名称，默认为'volces'
+ * @returns {Promise<string>} - 返回生成的文章JSON字符串
+ */
+export async function generateArticle(content, provider = 'volces1-5') {
+    try {
+        const aiProvider = AIProviderFactory.getProvider(provider);
+        const result = await aiProvider.generateArticle(content);
+        return result;
+    } catch (error) {
+        console.error("Generate article error:", error);
+        throw error;
+    }
+}
+
+/**
+ * 校验和修复JSON结构
+ * @param {string} jsonString - JSON字符串
+ * @returns {string} - 修复后的JSON字符串
+ */
+export function validateAndFixJSON(jsonString) {
+    try {
+        //console.log(jsonString);
+        // 解析JSON字符串为对象
+        let jsonObj = JSON.parse(jsonString);
+        
+        // 校验和修复Question数组中的每个问题对象
+        if (jsonObj.Question && Array.isArray(jsonObj.Question)) {
+            jsonObj.Question = jsonObj.Question.map(question => {
+                // 创建一个修复后的问题对象
+                const fixedQuestion = {};
+                
+                // 确保QuestionEnglish字段存在
+                if (question.QuestionEnglish) {
+                    fixedQuestion.QuestionEnglish = question.QuestionEnglish;
+                }
+                
+                // 检查QuestionChinese字段，如果不存在但有第二个QuestionEnglish，则使用它
+                if (question.QuestionChinese) {
+                    fixedQuestion.QuestionChinese = question.QuestionChinese;
+                } else if (Object.keys(question).filter(key => key === 'QuestionEnglish').length > 1) {
+                    // 找到第二个QuestionEnglish的值
+                    const keys = Object.keys(question);
+                    let foundFirst = false;
+                    for (const key of keys) {
+                        if (key === 'QuestionEnglish') {
+                            if (foundFirst) {
+                                fixedQuestion.QuestionChinese = question[key];
+                                break;
+                            }
+                            foundFirst = true;
+                        }
+                    }
+                }
+                
+                // 确保OptionsEnglish字段存在且为数组
+                if (question.OptionsEnglish && Array.isArray(question.OptionsEnglish)) {
+                    fixedQuestion.OptionsEnglish = question.OptionsEnglish;
+                } else {
+                    fixedQuestion.OptionsEnglish = ["A.", "B.", "C.", "D."];
+                }
+                
+                // 确保OptionsChinese字段存在且为数组
+                if (question.OptionsChinese && Array.isArray(question.OptionsChinese)) {
+                    fixedQuestion.OptionsChinese = question.OptionsChinese;
+                } else {
+                    fixedQuestion.OptionsChinese = ["A.", "B.", "C.", "D."];
+                }
+                
+                // 确保Answer字段存在
+                if (question.Answer) {
+                    fixedQuestion.Answer = question.Answer;
+                } else {
+                    fixedQuestion.Answer = "A";
+                }
+                
+                return fixedQuestion;
+            });
+        }
+        
+        // 确保其他必要字段存在
+        if (!jsonObj.ArticleEnglish || !Array.isArray(jsonObj.ArticleEnglish)) {
+            jsonObj.ArticleEnglish = ["No content available"];
+        }
+        
+        if (!jsonObj.ArticleChinese || !Array.isArray(jsonObj.ArticleChinese)) {
+            jsonObj.ArticleChinese = ["无可用内容"];
+        }
+        
+        if (!jsonObj.FormsOfWords || !Array.isArray(jsonObj.FormsOfWords)) {
+            jsonObj.FormsOfWords = [];
+        } else {
+            // 处理FormsOfWords数组，提取所有单词
+            const processedFormsOfWords = [];
+            
+            for (const item of jsonObj.FormsOfWords) {
+                if (typeof item !== 'string') {
+                    continue; // 跳过非字符串项
+                }
+                
+                // 处理冒号分隔格式："word1: word2"
+                if (item.includes(':')) {
+                    const [leftWord, rightWord] = item.split(':').map(word => word.trim());
+                    if (leftWord) processedFormsOfWords.push(leftWord);
+                    if (rightWord) processedFormsOfWords.push(rightWord);
+                    continue;
+                }
+                
+                // 处理括号分隔格式："word1(word2)" 或 "word1(word2, word3)"
+                const bracketMatch = item.match(/^([^(]+)\(([^)]+)\)$/);
+                if (bracketMatch) {
+                    const outsideWord = bracketMatch[1].trim();
+                    const insideWords = bracketMatch[2].split(',').map(word => word.trim());
+                    
+                    if (outsideWord) processedFormsOfWords.push(outsideWord);
+                    for (const word of insideWords) {
+                        if (word) processedFormsOfWords.push(word);
+                    }
+                    continue;
+                }
+                
+                // 如果不符合上述格式，检查是否包含逗号
+                if (item.includes(',')) {
+                    // 如果包含逗号，按逗号分割并添加每个单词
+                    const words = item.split(',').map(word => word.trim());
+                    for (const word of words) {
+                        if (word) processedFormsOfWords.push(word);
+                    }
+                } else {
+                    // 单个单词，直接添加
+                    processedFormsOfWords.push(item);
+                }
+            }
+            
+            // 去除空字符串并去重
+            const uniqueFormsOfWords = [...new Set(processedFormsOfWords.filter(word => word))];
+            
+            // 用去重后的数组替换原数组
+            jsonObj.FormsOfWords = uniqueFormsOfWords;
+        }
+        
+        // 将修复后的对象转回JSON字符串
+        return JSON.stringify(jsonObj);
+    } catch (jsonError) {
+        console.error("JSON解析或修复错误:", jsonError);
+        // 如果解析失败，保留原始结果
+        return jsonString;
+    }
+}
+
+export default {
+    generateArticle,
+    validateAndFixJSON
+};

src/api/yjbdc/yjbdcController.js

@@ -9,6 +9,7 @@ import { stringUtils } from '../../util/stringClass.js';
 import WXBizDataCrypt from '../../util/WXBizDataCrypt.js';
 import { globalCache } from '../../util/GlobalCache.js';
 import yjbdc from '../../model/yjbdc.js';
+import aiController from './aiController.js';
 
 import PDFDocument from 'pdfkit';
 import tencentcloud from 'tencentcloud-sdk-nodejs-ocr';
@@ -16,11 +17,8 @@ import tencentcloud from 'tencentcloud-sdk-nodejs-ocr';
 const ONE_DAY_MAX_BUILD_COUNT=12;//一天最大生成数
 
 const OcrClient = tencentcloud.ocr.v20181119.Client;
-const headers = {
-    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.65 Safari/537.36',
-    "Authorization": "Bearer "+config.huoshancloud.apikey,
-    "Content-Type": "application/json"
-}
+// AI平台配置
+const DEFAULT_AI_PROVIDER = 'volces1-6'; // 默认使用火山云AI
 
 
 export async function YJBDCLogin(ctx) {
@@ -262,102 +260,17 @@ export async function GenerateArticle(ctx) {
         
 
         //console.log("content:"+content);
-        const url = "https://ark.cn-beijing.volces.com/api/v3/chat/completions";
-        const postJSON = {
-            "model": "doubao-1.5-pro-32k-250115",
-            "messages": [
-            {
-                "role": "user",
-                "content": content,
-            }
-        ]};
-        try{
-            const response = await axios.post(encodeURI(url), postJSON, { headers });
-
-            
-            //console.log("parsedBody:" + JSON.stringify(response.data.choices[0].message.content));
-
-            let result2=response.data.choices[0].message.content;
+        
+        // 从请求参数中获取AI提供者，如果没有指定则使用默认值
+        const aiProvider = params.aiProvider || DEFAULT_AI_PROVIDER;
+        
+        try {
+            // 使用aiController生成文章
+            let result2 = await aiController.generateArticle(content, aiProvider);
             
             // 校验和修复JSON结构
-            try {
-                // 解析JSON字符串为对象
-                let jsonObj = JSON.parse(result2);
-                
-                // 校验和修复Question数组中的每个问题对象
-                if (jsonObj.Question && Array.isArray(jsonObj.Question)) {
-                    jsonObj.Question = jsonObj.Question.map(question => {
-                        // 创建一个修复后的问题对象
-                        const fixedQuestion = {};
-                        
-                        // 确保QuestionEnglish字段存在
-                        if (question.QuestionEnglish) {
-                            fixedQuestion.QuestionEnglish = question.QuestionEnglish;
-                        }
-                        
-                        // 检查QuestionChinese字段，如果不存在但有第二个QuestionEnglish，则使用它
-                        if (question.QuestionChinese) {
-                            fixedQuestion.QuestionChinese = question.QuestionChinese;
-                        } else if (Object.keys(question).filter(key => key === 'QuestionEnglish').length > 1) {
-                            // 找到第二个QuestionEnglish的值
-                            const keys = Object.keys(question);
-                            let foundFirst = false;
-                            for (const key of keys) {
-                                if (key === 'QuestionEnglish') {
-                                    if (foundFirst) {
-                                        fixedQuestion.QuestionChinese = question[key];
-                                        break;
-                                    }
-                                    foundFirst = true;
-                                }
-                            }
-                        }
-                        
-                        // 确保OptionsEnglish字段存在且为数组
-                        if (question.OptionsEnglish && Array.isArray(question.OptionsEnglish)) {
-                            fixedQuestion.OptionsEnglish = question.OptionsEnglish;
-                        } else {
-                            fixedQuestion.OptionsEnglish = ["A.", "B.", "C.", "D."];
-                        }
-                        
-                        // 确保OptionsChinese字段存在且为数组
-                        if (question.OptionsChinese && Array.isArray(question.OptionsChinese)) {
-                            fixedQuestion.OptionsChinese = question.OptionsChinese;
-                        } else {
-                            fixedQuestion.OptionsChinese = ["A.", "B.", "C.", "D."];
-                        }
-                        
-                        // 确保Answer字段存在
-                        if (question.Answer) {
-                            fixedQuestion.Answer = question.Answer;
-                        } else {
-                            fixedQuestion.Answer = "A";
-                        }
-                        
-                        return fixedQuestion;
-                    });
-                }
-                
-                // 确保其他必要字段存在
-                if (!jsonObj.ArticleEnglish || !Array.isArray(jsonObj.ArticleEnglish)) {
-                    jsonObj.ArticleEnglish = ["No content available"];
-                }
-                
-                if (!jsonObj.ArticleChinese || !Array.isArray(jsonObj.ArticleChinese)) {
-                    jsonObj.ArticleChinese = ["无可用内容"];
-                }
-                
-                if (!jsonObj.FormsOfWords || !Array.isArray(jsonObj.FormsOfWords)) {
-                    jsonObj.FormsOfWords = [];
-                }
-                
-                // 将修复后的对象转回JSON字符串
-                result2 = JSON.stringify(jsonObj);
-                console.log("JSON结构已校验和修复");
-            } catch (jsonError) {
-                console.error("JSON解析或修复错误:", jsonError);
-                // 如果解析失败，保留原始结果
-            }
+            result2 = aiController.validateAndFixJSON(result2);
+            console.log("JSON结构已校验和修复");
             
             let param2={};
             param2.UserID=ctx.query.UserID;
@@ -604,8 +517,26 @@ export async function GeneratePDF(ctx) {
         });
 
         // 6. 文章内容
-        doc.font('Helvetica')
-           .fontSize(pixelToPt(48))
+        // 先计算文章内容的行数
+        doc.font('Helvetica');
+        
+        // 使用48字号计算文本高度
+        const fontSize48 = pixelToPt(48);
+        doc.fontSize(fontSize48);
+        const textHeight48 = doc.heightOfString(articleText, {
+            width: pixelToPt(1240),
+            lineGap: pixelToPt(40.5)
+        });
+        
+        // 计算行数 (文本高度 / (字体大小 + 行间距))
+        const lineHeight = fontSize48 + pixelToPt(40.5);
+        const lineCount = Math.ceil(textHeight48 / lineHeight);
+        
+        // 如果行数超过18行，则使用42字号
+        const fontSize = lineCount > 18 ? pixelToPt(42) : pixelToPt(48);
+        
+        // 渲染文章内容
+        doc.fontSize(fontSize)
            .text(articleText, pixelToPt(740), pixelToPt(105), {
                width: pixelToPt(1240),
                lineGap: pixelToPt(40.5)

src/config/index.js

@@ -73,7 +73,8 @@ const commonConfig = {
         secretKey: "JTUK0WsBKJ8nIdopfM0TnxwkOsBJ75vp",
     },
     huoshancloud:{
-        apikey:"d276e65d-4c39-49ad-a2e2-5060c30ca9a0",
+        apikeyCJ:"d276e65d-4c39-49ad-a2e2-5060c30ca9a0",
+        apikeyHLR:"2b7d737e-6773-4d55-ae77-da8d4e819c96",
     },
     BufferMemoryTimeSuperLower:1,//缓存时间1秒
     BufferMemoryTimeLower:5,//缓存时间5秒

src/model/mps.js

@@ -225,7 +225,7 @@ class MPS {
 // 当前年份配置
 export const ArrYear = [{
     Name: "2025",
-    IsNullScoreLine: (moment().format("MM-DD") >= "05-30" && moment().format("MM-DD") <= "07-14") ? true : false, // 当只有计划没有分数线时
+    IsNullScoreLine: (moment().format("MM-DD") >= "05-30" && moment().format("MM-DD") < "07-14") ? true : false, // 当只有计划没有分数线时
     CSS: "Selected"
 }, {
     Name: "2024",