0

src/api/yjbdc/enhanceFormsOfWords.js

@@ -38,10 +38,10 @@ function levenshteinDistance(a, b) {
 }
 
 /**
- * 增强FormsOfWords，检测文章中单词的变形形式和拼写错误
+ * 增强FormsOfWords，检测文章中单词的变形形式和拼写错误，并添加翻译
  * @param {Object} jsonObj - 解析后的JSON对象
  * @param {string} userWords - 用户提供的单词列表，逗号分隔
- * @returns {Object} - 增强后的JSON对象，其中FormsOfWords是字符串数组
+ * @returns {Object} - 增强后的JSON对象，其中FormsOfWords是英文单词数组，FormsOfWordsChinese是对应的中文翻译数组
  */
 export function enhanceFormsOfWords(jsonObj, userWords) {
     if (!jsonObj || !userWords) return jsonObj;
@@ -54,8 +54,30 @@ export function enhanceFormsOfWords(jsonObj, userWords) {
         return jsonObj;
     }
     
-    // 创建FormsOfWords数组，首先包含所有用户输入的单词
-    const formsOfWordsArray = [...userWordsList];
+    // 创建单词翻译映射表
+    const wordTranslations = {};
+    
+    // 处理WordChinese字段，提取单词翻译
+    if (jsonObj.WordChinese && Array.isArray(jsonObj.WordChinese)) {
+        jsonObj.WordChinese.forEach(item => {
+            const parts = item.split(':');
+            if (parts.length >= 2) {
+                const word = parts[0].trim().toLowerCase();
+                const translation = parts.slice(1).join(':').trim();
+                wordTranslations[word] = translation;
+            }
+        });
+    }
+    
+    // 创建FormsOfWords数组和FormsOfWordsChinese数组
+    const formsOfWordsArray = [];
+    const formsOfWordsChineseArray = [];
+    
+    // 首先添加用户输入的单词
+    userWordsList.forEach(word => {
+        formsOfWordsArray.push(word);
+        formsOfWordsChineseArray.push(wordTranslations[word] || "");
+    });
     
     // 存储原始句子和小写句子的映射，用于保留大小写
     const originalSentences = {};
@@ -349,16 +371,58 @@ export function enhanceFormsOfWords(jsonObj, userWords) {
             }
         });
         
-        // 将找到的匹配形式添加到结果数组中
+        // 将找到的匹配形式添加到结果数组中，并添加翻译
         matchedForms.forEach(form => {
-            if (!formsOfWordsArray.includes(form)) {
+            // 检查是否已经存在于结果数组中
+            const formLower = form.toLowerCase();
+            const existingIndex = formsOfWordsArray.findIndex(item => 
+                item.toLowerCase() === formLower
+            );
+            
+            if (existingIndex === -1) {
+                // 查找原始单词的翻译
+                let translation = null;
+                
+                // 检查不规则动词的特殊情况
+                const irregularVerbs = {
+                    'be': ['am', 'is', 'are', 'was', 'were', 'been', 'being'],
+                    // 其他不规则动词...
+                };
+                
+                // 查找这个单词是否是某个不规则动词的变形
+                for (const [baseWord, forms] of Object.entries(irregularVerbs)) {
+                    if (forms.includes(formLower) && wordTranslations[baseWord]) {
+                        translation = wordTranslations[baseWord];
+                        break;
+                    }
+                }
+                
+                // 如果没有找到特殊情况的翻译，尝试查找原始单词的翻译
+                if (!translation) {
+                    for (const originalWord of userWordsList) {
+                        if (checkSpecialWordForms(formLower, originalWord) || 
+                            checkSpecialWordForms(originalWord, formLower)) {
+                            translation = wordTranslations[originalWord];
+                            if (translation) break;
+                        }
+                    }
+                }
+                
+                // 添加单词和对应的翻译到各自的数组
                 formsOfWordsArray.push(form);
+                formsOfWordsChineseArray.push(translation || "");
             }
         });
     });
     
-    // 将结果数组赋值给jsonObj.FormsOfWords
+    // 将结果数组赋值给jsonObj的相应字段
     jsonObj.FormsOfWords = formsOfWordsArray;
+    jsonObj.FormsOfWordsChinese = formsOfWordsChineseArray;
+    
+    // 删除 WordChinese 字段，因为已经将翻译整合到 FormsOfWordsChinese 中
+    if (jsonObj.WordChinese) {
+        delete jsonObj.WordChinese;
+    }
     
     return jsonObj;
 }

src/api/yjbdc/routes.js

@@ -15,6 +15,9 @@ router.get('/api/BuildYJBDCQRCode',yjbdcController.BuildYJBDCQRCode);
 router.get('/api/DeleteYJBDCArticleList',yjbdcController.DeleteYJBDCArticleList);
 router.get('/api/UpdateYJBDCArticleReadCount',yjbdcController.UpdateYJBDCArticleReadCount);
 router.get('/api/GetMiaoguoTodayAllWords',yjbdcController.GetMiaoguoTodayAllWords);
+router.get('/api/GetWordChinese',yjbdcController.GetWordChinese);
+
 router.get('/yjbdc_article_admin',yjbdcController.YJBDC_Articles_Admin);
 
+
 export default router;

src/api/yjbdc/yjbdcController.js

@@ -218,11 +218,13 @@ export async function GenerateArticle(ctx) {
                     "每句分数组提供中英双语，ArticleEnglish必须纯英文不含中文，ArticleChinese必须纯中文不含未翻译的英文单词",
                     "所有单词至少出现一次（允许变形）",
                     "生成5道四选一阅读题（含答案）",
+                    "提供用户单词在文中中文翻译",
                     "所有字段必须完整出现，任何缺失需立即补全并维持原顺序，特别是Question中的所有字段(QuestionEnglish、QuestionChinese、OptionsEnglish、OptionsChinese、Answer)都必须存在"
                 ],
                 "output_format": {
                     "ArticleEnglish": ["句子1", "句子2..."],
                     "ArticleChinese": ["翻译1", "翻译2..."],
+                    "WordChinese": ["单词1:翻译1", "单词2:翻译2..."],
                     "Question": [{
                     "QuestionEnglish": "题干",
                     "QuestionChinese": "题干翻译",
@@ -390,7 +392,7 @@ export async function GetYJBDCGenerateConfig(ctx) {
     ctx.body = {"errcode": 10000, result:result};
 }
 
-//获得秒过当天任务完成后的英语单词（未完成）
+//获得秒过当天任务完成后的英语单词
 export async function GetMiaoguoTodayAllWords(ctx) {
     const param = {
         UserID: ctx.query.UserID || 0,
@@ -1243,6 +1245,104 @@ export async function BuildYJBDCQRCode(ctx) {
     }
 }
 
+export async function GetWordChinese(ctx) {
+    const param = {
+        UserID: ctx.query.UserID || 0,
+        Word: ctx.query.Word || '',
+        Level: ctx.query.Level || '0'
+    };
+    
+    if (!param.Word) {
+        ctx.body = {"errcode": 10001, "errStr": "单词不能为空"};
+        return;
+    }
+    
+    // 使用单词作为缓存键，为每个单词单独缓存结果
+    const cacheKey = `GetWordChinese_${param.Word}_${param.Level}`;
+    let result = globalCache.get(cacheKey);
+    
+    if (!result) {
+        // 缓存未命中，从数据库获取
+        result = await yjbdc.GetWordChinese(param);
+        
+        // 如果没有找到结果，尝试查找单词的原形
+        if (!result || result.length === 0) {
+            // 使用stringUtils.getWordBaseForm获取可能的原形
+            const possibleBaseWords = stringUtils.getWordBaseForm(param.Word);
+            
+            // 尝试每个可能的原形
+            for (const baseWord of possibleBaseWords) {
+                console.log(`尝试查找单词 ${param.Word} 的可能原形: ${baseWord}`);
+                const baseParam = {...param, Word: baseWord};
+                const baseResult = await yjbdc.GetWordChinese(baseParam);
+                
+                if (baseResult && baseResult.length > 0) {
+                    console.log(`找到单词 ${param.Word} 的原形 ${baseWord}`);
+                    result = baseResult;
+                    break;
+                }
+            }
+        }
+        
+        // 缓存结果，使用较长的过期时间，因为单词释义很少变化
+        if (result && result.length > 0) {
+            globalCache.set(cacheKey, result, config.BufferMemoryTimeHighBest);
+            console.log(`缓存单词 ${param.Word} 的释义，7天有效期`);
+        }
+    }
+
+    // 根据Level筛选合适的单词释义
+    let selectedResult = null;
+    if (result && result.length > 0) {
+        // 将Level转换为数字
+        const level = parseInt(param.Level);
+        
+        // 根据不同Level筛选结果
+        if (level >= 0 && level <= 2) {
+            // Level 0-2，返回数组单词第一条
+            selectedResult = result[0];
+        } else if (level === 3) {
+            // Level 3，优选返回BookID >= 169的
+            const filtered = result.filter(item => item.BookID >= 169);
+            if (filtered.length > 0) {
+                selectedResult = filtered[0];
+            } else {
+                // 如果没有符合条件的，返回BookID较大的第一条
+                result.sort((a, b) => b.BookID - a.BookID);
+                selectedResult = result[0];
+            }
+        } else if (level === 4) {
+            // Level 4，优选返回BookID >= 173的
+            const filtered = result.filter(item => item.BookID >= 173);
+            if (filtered.length > 0) {
+                selectedResult = filtered[0];
+            } else {
+                // 如果没有符合条件的，返回BookID较大的第一条
+                result.sort((a, b) => b.BookID - a.BookID);
+                selectedResult = result[0];
+            }
+        } else if (level === 5) {
+            // Level 5，优选返回BookID >= 178的
+            const filtered = result.filter(item => item.BookID >= 178);
+            if (filtered.length > 0) {
+                selectedResult = filtered[0];
+            } else {
+                // 如果没有符合条件的，返回BookID较大的第一条
+                result.sort((a, b) => b.BookID - a.BookID);
+                selectedResult = result[0];
+            }
+        }
+        
+        // 移除 BookID 字段
+        if (selectedResult) {
+            delete selectedResult.BookID;
+        }
+    }
+
+    ctx.body = {"errcode": 10000, result: selectedResult};
+}
+
+
 export async function YJBDC_Articles_Admin(ctx) {
     console.log("yjbdc_articles");
     const data = await fsPromises.readFile("./public/mg/yjbdc_articles.html");

src/model/yjbdc.js

@@ -151,6 +151,17 @@ class YJBDC {
         }
     }
 
+    static async GetWordChinese(obj) {
+        try {
+            // 直接在数据库层面过滤出特定单词，获取包含BookID的数据
+            const sql = "SELECT Word, Translate, BookID FROM kylx365_db.Words w WHERE w.Word = ? AND ((w.BookID>=151 AND w.BookID<=153) OR (w.BookID>=169 AND w.BookID<=183)) ORDER BY w.BookID;";
+            return await query(sql, [obj.Word]);
+        } catch (error) {
+            console.error('获取单词信息失败:', error);
+            throw error;
+        }
+    }
+
 
 }
 

src/util/stringClass.js

@@ -67,6 +67,35 @@ import os from 'os';
  * @property {Function} cleanWord - 清理单词中的非字母字符
  * @property {Function} extractEnglishWords - 从文本中提取英语单词
  */
+// 不规则动词映射
+const irregularVerbs = {
+    'go': ['went', 'gone', 'going', 'goes'],
+    'be': ['am', 'is', 'are', 'was', 'were', 'been', 'being'],
+    'do': ['did', 'done', 'doing', 'does'],
+    'have': ['has', 'had', 'having'],
+    'say': ['said', 'saying', 'says'],
+    'make': ['made', 'making', 'makes'],
+    'get': ['got', 'gotten', 'getting', 'gets'],
+    'know': ['knew', 'known', 'knowing', 'knows'],
+    'take': ['took', 'taken', 'taking', 'takes'],
+    'see': ['saw', 'seen', 'seeing', 'sees'],
+    'come': ['came', 'coming', 'comes'],
+    'think': ['thought', 'thinking', 'thinks'],
+    'look': ['looked', 'looking', 'looks'],
+    'want': ['wanted', 'wanting', 'wants'],
+    'give': ['gave', 'given', 'giving', 'gives'],
+    'use': ['used', 'using', 'uses'],
+    'find': ['found', 'finding', 'finds'],
+    'tell': ['told', 'telling', 'tells'],
+    'ask': ['asked', 'asking', 'asks'],
+    'work': ['worked', 'working', 'works'],
+    'seem': ['seemed', 'seeming', 'seems'],
+    'feel': ['felt', 'feeling', 'feels'],
+    'try': ['tried', 'trying', 'tries'],
+    'leave': ['left', 'leaving', 'leaves'],
+    'call': ['called', 'calling', 'calls']
+};
+
 export const stringUtils = {
     //给字符串左侧补零
     AddZero: (str, length) => {
@@ -725,4 +754,95 @@ export const stringUtils = {
         //console.groupEnd();
         return result;
     },
+    
+    /**
+     * 获取单词的原形（基本形式）
+     * @param {string} word - 要转换的单词
+     * @returns {string[]} - 可能的原形单词数组
+     */
+    getWordBaseForm: (word) => {
+        const lowerWord = word.toLowerCase();
+        const possibleBaseWords = [];
+        
+        // 检查是否是不规则动词的变形
+        for (const [base, forms] of Object.entries(irregularVerbs)) {
+            if (forms.includes(lowerWord)) {
+                possibleBaseWords.push(base);
+                return possibleBaseWords; // 不规则动词直接返回原形
+            }
+        }
+        
+        // 处理规则变形
+        
+        // 处理过去式/过去分词 (-ed)
+        if (lowerWord.endsWith('ed')) {
+            possibleBaseWords.push(lowerWord.slice(0, -2)); // 常规情况 (walked -> walk)
+        }
+        
+        // 处理以e结尾的动词加d的情况
+        if (lowerWord.endsWith('d') && !lowerWord.endsWith('ed')) {
+            possibleBaseWords.push(lowerWord.slice(0, -1)); // 如 used -> use
+        }
+        
+        // 处理以辅音+y结尾变为ied的情况
+        if (lowerWord.endsWith('ied')) {
+            possibleBaseWords.push(lowerWord.slice(0, -3) + 'y'); // 如 tried -> try
+        }
+        
+        // 处理现在分词 (-ing)
+        if (lowerWord.endsWith('ing')) {
+            possibleBaseWords.push(lowerWord.slice(0, -3)); // 常规情况 (walking -> walk)
+            possibleBaseWords.push(lowerWord.slice(0, -3) + 'e'); // 以e结尾的动词 (making -> make)
+        }
+        
+        // 处理比较级/最高级
+        if (lowerWord.endsWith('er')) {
+            possibleBaseWords.push(lowerWord.slice(0, -2)); // 常规情况 (faster -> fast)
+        }
+        if (lowerWord.endsWith('est')) {
+            possibleBaseWords.push(lowerWord.slice(0, -3)); // 常规情况 (fastest -> fast)
+        }
+        
+        // 处理以辅音+y结尾变为ier/iest的情况
+        if (lowerWord.endsWith('ier')) {
+            possibleBaseWords.push(lowerWord.slice(0, -3) + 'y'); // 如 happier -> happy
+        }
+        if (lowerWord.endsWith('iest')) {
+            possibleBaseWords.push(lowerWord.slice(0, -4) + 'y'); // 如 happiest -> happy
+        }
+        
+        // 处理副词 (-ly)
+        if (lowerWord.endsWith('ly')) {
+            possibleBaseWords.push(lowerWord.slice(0, -2)); // 常规情况 (quickly -> quick)
+        }
+        
+        // 处理以y结尾变为ily的情况
+        if (lowerWord.endsWith('ily')) {
+            possibleBaseWords.push(lowerWord.slice(0, -3) + 'y'); // 如 happily -> happy
+        }
+        
+        // 处理复数形式
+        if (lowerWord.endsWith('s') && !lowerWord.endsWith('ss')) {
+            possibleBaseWords.push(lowerWord.slice(0, -1)); // 常规情况 (books -> book)
+        }
+        if (lowerWord.endsWith('es')) {
+            possibleBaseWords.push(lowerWord.slice(0, -2)); // 常规情况 (boxes -> box)
+        }
+        
+        // 处理以y结尾变为ies的情况
+        if (lowerWord.endsWith('ies')) {
+            possibleBaseWords.push(lowerWord.slice(0, -3) + 'y'); // 如 cities -> city
+        }
+        
+        // 处理以fe结尾变为ves的情况
+        if (lowerWord.endsWith('ves')) {
+            possibleBaseWords.push(lowerWord.slice(0, -3) + 'fe'); // 如 knives -> knife
+            possibleBaseWords.push(lowerWord.slice(0, -3) + 'f'); // 如 leaves -> leaf
+        }
+        
+        // 去重并过滤掉过短的单词
+        const uniqueBaseWords = [...new Set(possibleBaseWords)].filter(w => w.length >= 2);
+        
+        return uniqueBaseWords;
+    },
 }