@qwe8652591/abap-recursive-query 1.1.0

package/dist/consumer/FileDownloadConsumer.js

@@ -0,0 +1,1003 @@
+"use strict";
+/**
+ * 文件下载消费者
+ * 负责从队列拉取任务并下载文件
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileDownloadConsumer = void 0;
+const { v4: uuidv4 } = require('uuid');
+const common_1 = require("../common");
+const handleGetClass_1 = require("./handlers/handleGetClass");
+const handleGetFunction_1 = require("./handlers/handleGetFunction");
+const handleGetProgram_1 = require("./handlers/handleGetProgram");
+const handleGetInclude_1 = require("./handlers/handleGetInclude");
+const download_1 = require("./utils/download");
+const generators_1 = require("./generators");
+const core_1 = require("@abaplint/core");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const { join, dirname } = path;
+const { mkdirSync, existsSync } = fs;
+/**
+ * 文件下载消费者
+ */
+class FileDownloadConsumer {
+    workerId;
+    queueManager;
+    isRunning = false;
+    activeJobIds = [];
+    downloadedFiles = [];
+    downloadRootPath;
+    organizeByProgram;
+    abaplintRegistry; // ✅ 复用的 abaplint Registry 实例
+    constructor(queueManager, downloadRootPath, jobIds, organizeByProgram = true) {
+        this.queueManager = queueManager;
+        this.workerId = `worker-${uuidv4()}`;
+        this.activeJobIds = jobIds || [];
+        this.downloadRootPath = downloadRootPath;
+        this.organizeByProgram = organizeByProgram;
+        // ✅ 优化：创建一次 abaplint Registry，后续复用
+        this.abaplintRegistry = new core_1.Registry(core_1.Config.getDefault());
+        // 确保下载目录存在
+        if (!existsSync(this.downloadRootPath)) {
+            mkdirSync(this.downloadRootPath, { recursive: true });
+        }
+    }
+    /**
+     * 启动消费者
+     */
+    async start(jobIds) {
+        this.isRunning = true;
+        this.activeJobIds = jobIds || await this.getActiveJobs();
+        console.error(`[Consumer ${this.workerId}] 🚀 消费者启动`);
+        if (this.activeJobIds.length > 0) {
+            console.error(`[Consumer ${this.workerId}] 📋 监听 ${this.activeJobIds.length} 个Job: ${this.activeJobIds.join(', ')}`);
+        }
+        else {
+            console.error(`[Consumer ${this.workerId}] ⏳ 等待Job...`);
+        }
+        while (this.isRunning) {
+            try {
+                // 从指定Job的队列拉取任务
+                const task = this.activeJobIds.length === 1
+                    ? await this.queueManager.pullTask(this.activeJobIds[0], 5)
+                    : await this.queueManager.pullTaskFromAnyJob(this.activeJobIds, 5);
+                if (!task) {
+                    // 超时，检查是否有新的Job
+                    const previousJobIds = this.activeJobIds;
+                    this.activeJobIds = await this.getActiveJobs();
+                    // 如果Job列表发生变化，输出日志
+                    if (JSON.stringify(previousJobIds) !== JSON.stringify(this.activeJobIds)) {
+                        if (this.activeJobIds.length > 0) {
+                            console.error(`[Consumer ${this.workerId}] 📋 更新Job列表: ${this.activeJobIds.join(', ')}`);
+                        }
+                        else {
+                            console.error(`[Consumer ${this.workerId}] ⏳ 等待新的Job...`);
+                        }
+                    }
+                    // 如果没有活跃的Job，等待一段时间
+                    if (this.activeJobIds.length === 0) {
+                        await this.sleep(1000);
+                    }
+                    continue;
+                }
+                // 处理任务
+                await this.processTask(task);
+            }
+            catch (error) {
+                console.error(`[Consumer ${this.workerId}] ⚠️  处理错误:`, error);
+            }
+        }
+        // 输出统计信息
+        const successCount = this.downloadedFiles.filter(f => f.success).length;
+        const failCount = this.downloadedFiles.filter(f => !f.success).length;
+        console.error(`[Consumer ${this.workerId}] 🛑 消费者已停止 (成功: ${successCount}, 失败: ${failCount}, 总计: ${this.downloadedFiles.length})`);
+    }
+    /**
+     * 停止消费者
+     */
+    async stop() {
+        this.isRunning = false;
+        console.error(`[Consumer ${this.workerId}] ⏹️  正在停止消费者...`);
+    }
+    /**
+     * 获取下载的文件列表
+     */
+    getDownloadedFiles() {
+        return this.downloadedFiles;
+    }
+    /**
+     * 处理任务
+     */
+    async processTask(task) {
+        const startTime = Date.now();
+        try {
+            // 📝 开始处理任务
+            const retryInfo = task.retryCount > 0 ? ` [重试 ${task.retryCount}/${task.maxRetries}]` : '';
+            console.error(`[Consumer ${this.workerId}] ⏳ 开始处理任务: ${task.objectKey} (深度: ${task.depth}, 优先级: ${task.priority})${retryInfo}`);
+            // 更新任务状态为运行中
+            await this.queueManager.updateTaskStatus(task.taskId, 'RUNNING', this.workerId);
+            // 1. 从Redis读取缓存的对象数据
+            const cachedData = await this.queueManager.getCache(task.jobId, task.objectKey);
+            if (!cachedData) {
+                throw new Error(`缓存数据不存在: ${task.objectKey}`);
+            }
+            console.error(`[Consumer ${this.workerId}]    ✓ 读取缓存成功: ${task.objectKey}`);
+            // 🎯 声明对象特定的根路径：根据配置决定是否按程序分目录
+            // - organizeByProgram = true: downloadRootPath/sanitizedObjectName/source/
+            // - organizeByProgram = false: downloadRootPath/source/
+            const objectRootPath = this.organizeByProgram
+                ? join(this.downloadRootPath, (0, common_1.sanitizeObjectName)(task.objectName), 'source')
+                : join(this.downloadRootPath, 'source');
+            // 确保对象根目录存在
+            if (!existsSync(objectRootPath)) {
+                mkdirSync(objectRootPath, { recursive: true });
+            }
+            // 2. 下载源代码
+            await this.downloadObjectSource(task, cachedData, objectRootPath);
+            console.error(`[Consumer ${this.workerId}]    ✓ 源代码下载完成: ${task.objectKey}`);
+            // 3. 处理附加数据
+            await this.processAdditionalData(task, cachedData, objectRootPath);
+            console.error(`[Consumer ${this.workerId}]    ✓ 附加数据处理完成: ${task.objectKey}`);
+            // 4. ✅ 先标记任务完成（避免缓存删除后崩溃导致重试失败）
+            await this.queueManager.completeTask(task.taskId);
+            // 5. ✅ 再清理缓存（即使失败也不影响任务状态）
+            try {
+                await this.queueManager.deleteCache(task.jobId, task.objectKey);
+                console.error(`[Consumer ${this.workerId}]    ✓ 缓存已清理: ${task.objectKey}`);
+            }
+            catch (cacheError) {
+                // 缓存删除失败不影响任务状态，只记录日志
+                console.error(`[Consumer ${this.workerId}]    ⚠️  缓存清理失败（不影响任务）: ${cacheError}`);
+            }
+            // 6. 获取并显示Job进度
+            const progress = await this.queueManager.getProgress(task.jobId);
+            const duration = Date.now() - startTime;
+            if (progress) {
+                const progressBar = this.generateProgressBar(progress.percentage);
+                console.error(`[Consumer ${this.workerId}] ✅ 任务完成: ${task.objectKey} (耗时: ${duration}ms)`);
+                console.error(`[Consumer ${this.workerId}] 📊 Job进度: ${progressBar} ${progress.percentage.toFixed(1)}% (${progress.completedTasks}/${progress.totalTasks})`);
+            }
+            else {
+                console.error(`[Consumer ${this.workerId}] ✅ 任务完成: ${task.objectKey} (耗时: ${duration}ms)`);
+            }
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const retryInfo = task.retryCount < task.maxRetries
+                ? `，将重试 (${task.retryCount + 1}/${task.maxRetries})`
+                : '，已达最大重试次数';
+            console.error(`[Consumer ${this.workerId}] ❌ 任务失败: ${task.objectKey} (耗时: ${duration}ms)`);
+            console.error(`[Consumer ${this.workerId}]    错误: ${errorMessage}${retryInfo}`);
+            // 标记任务失败（会自动重试）
+            await this.queueManager.failTask(task.taskId, errorMessage);
+        }
+    }
+    /**
+     * 生成进度条
+     */
+    generateProgressBar(percentage, length = 20) {
+        const filled = Math.floor((percentage / 100) * length);
+        const empty = length - filled;
+        return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
+    }
+    /**
+     * 下载对象源代码
+     */
+    async downloadObjectSource(task, cachedData, objectRootPath) {
+        const { objectType, objectName } = task;
+        // ✅ 优化：生成文件路径并检查是否已存在
+        const filePath = this.generateFilePath(objectName, objectType, objectRootPath);
+        if (existsSync(filePath)) {
+            const stats = fs.statSync(filePath);
+            // 检查文件大小（避免空文件或损坏文件）
+            if (stats.size > 0) {
+                console.error(`[Consumer ${this.workerId}] 文件已存在，跳过下载: ${filePath} (${stats.size} bytes)`);
+                // 记录到下载列表
+                this.downloadedFiles.push({
+                    objectName,
+                    objectType,
+                    filePath,
+                    success: true
+                });
+                return;
+            }
+            else {
+                console.error(`[Consumer ${this.workerId}] 发现空文件，重新下载: ${filePath}`);
+            }
+        }
+        try {
+            let sourceResult;
+            let functionGroup = null;
+            switch (objectType.toUpperCase()) {
+                case 'CLASS':
+                    sourceResult = await (0, handleGetClass_1.handleGetClass)({ class_name: objectName });
+                    break;
+                case 'FUNCTION':
+                    // 从缓存数据中提取函数组
+                    functionGroup = this.extractFunctionGroup(cachedData);
+                    if (!functionGroup) {
+                        functionGroup = objectName.split('_')[0] || objectName;
+                    }
+                    sourceResult = await (0, handleGetFunction_1.handleGetFunction)({
+                        function_name: objectName,
+                        function_group: functionGroup
+                    });
+                    break;
+                case 'PROGRAM':
+                    sourceResult = await (0, handleGetProgram_1.handleGetProgram)({ program_name: objectName });
+                    break;
+                default:
+                    console.error(`[Consumer ${this.workerId}] 不支持的对象类型: ${objectType}`);
+                    return;
+            }
+            // 检查结果
+            if (!sourceResult || sourceResult.isError) {
+                const errorText = Array.isArray(sourceResult?.content) && sourceResult.content.length > 0
+                    ? sourceResult.content[0].text || '未知错误'
+                    : '未知错误';
+                throw new Error(`获取源代码失败: ${errorText}`);
+            }
+            if (!sourceResult.content || !Array.isArray(sourceResult.content) || sourceResult.content.length === 0) {
+                throw new Error('源代码为空');
+            }
+            // 提取源代码
+            const sourceContent = sourceResult.content.map((item) => item.text || '').join('\n');
+            // 确保目录存在（filePath 已在方法开头生成）
+            const dirPath = dirname(filePath);
+            if (!existsSync(dirPath)) {
+                mkdirSync(dirPath, { recursive: true });
+            }
+            // 下载文件
+            const downloadResult = await (0, download_1.downloadFile)(sourceContent, filePath, 'abap');
+            this.downloadedFiles.push({
+                objectName,
+                objectType,
+                filePath,
+                success: downloadResult.success,
+                error: downloadResult.success ? undefined : downloadResult.message
+            });
+            if (downloadResult.success) {
+                console.error(`[Consumer ${this.workerId}] 源代码下载成功: ${objectType}/${objectName} -> ${filePath}`);
+            }
+            else {
+                console.error(`[Consumer ${this.workerId}] 源代码下载失败: ${objectType}/${objectName} - ${downloadResult.message}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[Consumer ${this.workerId}] 下载源代码失败: ${objectType}/${objectName} - ${errorMessage}`);
+            throw error;
+        }
+    }
+    /**
+     * 处理附加数据
+     */
+    async processAdditionalData(task, cachedData, objectRootPath) {
+        const { objectType, objectName } = task;
+        try {
+            // ✅ 处理对象元数据（对所有对象类型）
+            await this.processObjectMetadata(task, cachedData, objectRootPath);
+            // 根据对象类型处理不同的附加数据
+            if (objectType.toUpperCase() === 'FUNCTION' && cachedData.ET_FUNCTION) {
+                await this.processFunctionData(task, cachedData.ET_FUNCTION, objectRootPath);
+            }
+            else if (objectType.toUpperCase() === 'PROGRAM' && cachedData.ET_PROGRAM) {
+                await this.processProgramData(task, cachedData.ET_PROGRAM, objectRootPath);
+            }
+            else if (objectType.toUpperCase() === 'CLASS' && cachedData.ET_CLASSES) {
+                await this.processClassData(task, cachedData.ET_CLASSES, objectRootPath);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[Consumer ${this.workerId}] 处理附加数据失败: ${task.objectKey} - ${errorMessage}`);
+            // 不抛出错误，允许主任务继续
+        }
+    }
+    /**
+     * 处理对象元数据
+     */
+    async processObjectMetadata(task, cachedData, objectRootPath) {
+        try {
+            // 提取元数据（当前包含依赖关系，未来可扩展更多信息）
+            const metadata = {
+                ET_REFCLASS: cachedData.ET_REFCLASS,
+                ET_REFFUNCTION: cachedData.ET_REFFUNCTION,
+                ET_REFPROGRAM: cachedData.ET_REFPROGRAM
+                // 未来可扩展：
+                // ET_TABLES: cachedData.ET_TABLES,
+                // ET_DDIC: cachedData.ET_DDIC,
+                // 等等...
+            };
+            // 生成元数据 XML
+            await (0, generators_1.generateMetadataXml)(metadata, task.objectName, task.objectType, objectRootPath, this.downloadedFiles);
+        }
+        catch (error) {
+            // 元数据处理失败不影响主流程
+            console.error(`[Consumer ${this.workerId}] 处理对象元数据失败: ${task.objectKey} -`, error);
+        }
+    }
+    /**
+     * 处理函数的附加数据
+     */
+    async processFunctionData(task, functions, objectRootPath) {
+        if (!functions || functions.length === 0) {
+            return;
+        }
+        for (const func of functions) {
+            const functionName = func.FUNCTIONNAME || task.objectName;
+            const progName = func.PROGNAME || '';
+            // 处理 Include 文件
+            if (func.IINCLUDES && Array.isArray(func.IINCLUDES)) {
+                for (const include of func.IINCLUDES) {
+                    if (include.INCLUDENAME) {
+                        await this.downloadInclude(include.INCLUDENAME, objectRootPath);
+                    }
+                }
+            }
+            // 处理结构体（保存为 JSON）
+            if (func.IDICTSTRUCT && Array.isArray(func.IDICTSTRUCT) && func.IDICTSTRUCT.length > 0) {
+                console.error(`[Consumer ${this.workerId}] 处理函数 ${functionName} 的结构体，共 ${func.IDICTSTRUCT.length} 个`);
+                await this.processStructures(func.IDICTSTRUCT, objectRootPath);
+            }
+            // 文本元素、屏幕等需要程序名
+            if (!progName) {
+                continue;
+            }
+            // 处理文本元素（添加去重）
+            if (func.ITEXTELEMENTS && Array.isArray(func.ITEXTELEMENTS) && func.ITEXTELEMENTS.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'textelements', progName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的文本元素处理: ${progName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'textelements', progName);
+                        await (0, generators_1.generateTextElementsXml)(func.ITEXTELEMENTS, progName, 'PROGRAM', objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理文本元素失败:`, error);
+                    }
+                }
+            }
+            // 处理消息（添加去重）
+            if (func.IMESSAGES && Array.isArray(func.IMESSAGES) && func.IMESSAGES.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'messages', progName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的消息处理: ${progName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'messages', progName);
+                        await (0, generators_1.generateMessageClassXml)(func.IMESSAGES, progName, objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理消息失败:`, error);
+                    }
+                }
+            }
+            // 处理GUI标题（添加去重）
+            if (func.IGUITITLE && Array.isArray(func.IGUITITLE) && func.IGUITITLE.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'guititle', progName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的GUI标题处理: ${progName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'guititle', progName);
+                        await (0, generators_1.generateGuiTitlesJson)(func.IGUITITLE, progName, 'PROGRAM', objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理GUI标题失败:`, error);
+                    }
+                }
+            }
+            // 处理GUI状态（添加去重）
+            if (func.IGUISTATUS && Array.isArray(func.IGUISTATUS) && func.IGUISTATUS.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'guistatus', progName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的GUI状态处理: ${progName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'guistatus', progName);
+                        await (0, generators_1.generateGuiStatusJson)(func.IGUISTATUS, progName, 'PROGRAM', objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理GUI状态失败:`, error);
+                    }
+                }
+            }
+            // 处理屏幕（添加去重）
+            if (func.ISCREENFIELD || func.ISCREENFLOW || func.ISCREENDESC) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'screens', progName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的屏幕处理: ${progName} (已处理)`);
+                }
+                else {
+                    // 标记为已处理
+                    await this.queueManager.markProcessed(task.jobId, 'screens', progName);
+                    await this.processScreens(func.ISCREENFIELD, func.ISCREENFLOW, func.ISCREENDESC, progName, objectRootPath);
+                }
+            }
+        }
+    }
+    /**
+     * 处理程序的附加数据
+     */
+    async processProgramData(task, programs, objectRootPath) {
+        if (!programs || programs.length === 0) {
+            return;
+        }
+        for (const prog of programs) {
+            const programName = prog.PROGNAME || task.objectName;
+            // 处理 Include 文件
+            if (prog.IINCLUDES && Array.isArray(prog.IINCLUDES)) {
+                for (const include of prog.IINCLUDES) {
+                    if (include.INCLUDENAME) {
+                        await this.downloadInclude(include.INCLUDENAME, objectRootPath);
+                    }
+                }
+            }
+            // 处理结构体
+            if (prog.IDICTSTRUCT && Array.isArray(prog.IDICTSTRUCT) && prog.IDICTSTRUCT.length > 0) {
+                console.error(`[Consumer ${this.workerId}] 处理程序 ${programName} 的结构体，共 ${prog.IDICTSTRUCT.length} 个`);
+                await this.processStructures(prog.IDICTSTRUCT, objectRootPath);
+            }
+            // 处理文本元素（添加去重）
+            if (prog.ITEXTELEMENTS && Array.isArray(prog.ITEXTELEMENTS) && prog.ITEXTELEMENTS.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'textelements', programName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的文本元素处理: ${programName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'textelements', programName);
+                        await (0, generators_1.generateTextElementsXml)(prog.ITEXTELEMENTS, programName, 'PROGRAM', objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理程序文本元素失败:`, error);
+                    }
+                }
+            }
+            // 处理消息（添加去重）
+            if (prog.IMESSAGES && Array.isArray(prog.IMESSAGES) && prog.IMESSAGES.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'messages', programName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的消息处理: ${programName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'messages', programName);
+                        await (0, generators_1.generateMessageClassXml)(prog.IMESSAGES, programName, objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理程序消息失败:`, error);
+                    }
+                }
+            }
+            // 处理GUI标题（添加去重）
+            if (prog.IGUITITLE && Array.isArray(prog.IGUITITLE) && prog.IGUITITLE.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'guititle', programName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的GUI标题处理: ${programName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'guititle', programName);
+                        await (0, generators_1.generateGuiTitlesJson)(prog.IGUITITLE, programName, 'PROGRAM', objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理程序GUI标题失败:`, error);
+                    }
+                }
+            }
+            // 处理GUI状态（添加去重）
+            if (prog.IGUISTATUS && Array.isArray(prog.IGUISTATUS) && prog.IGUISTATUS.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'guistatus', programName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的GUI状态处理: ${programName} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'guistatus', programName);
+                        await (0, generators_1.generateGuiStatusJson)(prog.IGUISTATUS, programName, 'PROGRAM', objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理程序GUI状态失败:`, error);
+                    }
+                }
+            }
+            // 处理屏幕（添加去重）
+            if (prog.ISCREENFIELD || prog.ISCREENFLOW || prog.ISCREENDESC) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'screens', programName)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的屏幕处理: ${programName} (已处理)`);
+                }
+                else {
+                    // 标记为已处理
+                    await this.queueManager.markProcessed(task.jobId, 'screens', programName);
+                    await this.processScreens(prog.ISCREENFIELD, prog.ISCREENFLOW, prog.ISCREENDESC, programName, objectRootPath);
+                }
+            }
+        }
+    }
+    /**
+     * 处理类的附加数据
+     */
+    async processClassData(task, classes, objectRootPath) {
+        if (!classes || classes.length === 0) {
+            return;
+        }
+        for (const cls of classes) {
+            const className = cls.CLSNAME || task.objectName;
+            // 处理结构体
+            if (cls.IDICTSTRUCT && Array.isArray(cls.IDICTSTRUCT) && cls.IDICTSTRUCT.length > 0) {
+                console.error(`[Consumer ${this.workerId}] 处理类 ${className} 的结构体，共 ${cls.IDICTSTRUCT.length} 个`);
+                await this.processStructures(cls.IDICTSTRUCT, objectRootPath);
+            }
+            // 处理文本元素（添加去重）
+            if (cls.ITEXTELEMENTS && Array.isArray(cls.ITEXTELEMENTS) && cls.ITEXTELEMENTS.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'textelements', className)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的文本元素处理: ${className} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'textelements', className);
+                        await (0, generators_1.generateTextElementsXml)(cls.ITEXTELEMENTS, className, 'CLASS', objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理类文本元素失败:`, error);
+                    }
+                }
+            }
+            // 处理消息（添加去重）
+            if (cls.IMESSAGES && Array.isArray(cls.IMESSAGES) && cls.IMESSAGES.length > 0) {
+                // 检查是否已处理
+                if (await this.queueManager.hasProcessed(task.jobId, 'messages', className)) {
+                    console.error(`[Consumer ${this.workerId}] 跳过重复的消息处理: ${className} (已处理)`);
+                }
+                else {
+                    try {
+                        // 标记为已处理
+                        await this.queueManager.markProcessed(task.jobId, 'messages', className);
+                        await (0, generators_1.generateMessageClassXml)(cls.IMESSAGES, className, objectRootPath, this.downloadedFiles);
+                    }
+                    catch (error) {
+                        console.error(`[Consumer ${this.workerId}] 处理类消息失败:`, error);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 下载 Include 文件并根据内容自动检测类型，添加符合 abaplint 规范的后缀
+     */
+    async downloadInclude(includeName, objectRootPath) {
+        try {
+            // 1. 获取 include 文件内容
+            const includeResult = await (0, handleGetInclude_1.handleGetInclude)({ include_name: includeName });
+            // 统一处理错误情况
+            if (!includeResult) {
+                throw new Error(`获取包含文件 ${includeName} 失败: 无响应数据`);
+            }
+            if (includeResult.isError) {
+                const errorText = Array.isArray(includeResult.content) && includeResult.content.length > 0
+                    ? includeResult.content[0].text || '未知错误'
+                    : '未知错误';
+                throw new Error(`获取包含文件 ${includeName} 失败: ${errorText}`);
+            }
+            if (!includeResult.content) {
+                throw new Error(`获取包含文件 ${includeName} 失败: 无有效内容返回`);
+            }
+            const content = Array.isArray(includeResult.content)
+                ? includeResult.content.map(item => item.text || '').join('\n')
+                : String(includeResult.content || '');
+            // 2. 分析内容并提取类型和真实名称
+            const { type: includeType, realName } = this.analyzeIncludeContent(content, includeName);
+            console.error(`[Consumer ${this.workerId}] 分析结果 - 类型: ${includeType}, 真实名称: ${realName}${realName !== includeName ? ` (原名: ${includeName})` : ''}`);
+            // 3. 根据真实名称和类型生成文件路径
+            const finalFilePath = this.generateIncludeFilePath(realName, includeType, objectRootPath);
+            // 确保目录存在
+            const dirPath = dirname(finalFilePath);
+            if (!existsSync(dirPath)) {
+                mkdirSync(dirPath, { recursive: true });
+            }
+            // 5. 下载文件
+            const downloadResult = await (0, download_1.downloadFile)(content, finalFilePath, 'abap');
+            this.downloadedFiles.push({
+                objectName: includeName,
+                objectType: 'INCLUDE',
+                filePath: finalFilePath,
+                success: downloadResult.success,
+                error: downloadResult.success ? undefined : downloadResult.message
+            });
+            if (downloadResult.success) {
+                const nameInfo = realName !== includeName ? `${includeName} → ${realName}` : includeName;
+                console.error(`[Consumer ${this.workerId}] Include 下载成功: ${nameInfo} [${includeType}] -> ${finalFilePath}`);
+            }
+            else {
+                console.error(`[Consumer ${this.workerId}] Include 下载失败: ${includeName} - ${downloadResult.message}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[Consumer ${this.workerId}] 下载 Include 失败: ${includeName} - ${errorMessage}`);
+        }
+    }
+    /**
+     * ✅ 分析 include 文件内容，返回类型和真实名称
+     * 使用 abaplint 进行精确的语法分析
+     * - 只对 FUNCTION 类型提取真实函数名
+     * - 其他类型（类、表单等）保持使用原始 include 名称
+     * - 遵循零硬编码原则：所有信息从源代码中动态提取
+     */
+    analyzeIncludeContent(content, fileName) {
+        console.error(`[Consumer ${this.workerId}] [内容分析] 使用 abaplint 分析文件: ${fileName}`);
+        let detectedType = 'STANDARD';
+        let extractedName = fileName; // 默认使用原始文件名
+        try {
+            // ✅ 优化：清空 Registry（保留配置），而不是创建新实例
+            this.abaplintRegistry.clear();
+            // abaplint 需要 .prog.abap 或类似后缀才能识别
+            const tempFileName = `${fileName}.prog.abap`;
+            const memFile = new core_1.MemoryFile(tempFileName, content);
+            this.abaplintRegistry.addFile(memFile);
+            this.abaplintRegistry.parse();
+            // 获取对象（abaplint 会尝试识别文件类型）
+            const obj = this.abaplintRegistry.findObjectForFile(memFile);
+            console.error(`[Consumer ${this.workerId}] [abaplint] 对象类型: ${obj ? obj.getType() : 'null'}`);
+            if (obj && obj instanceof core_1.ABAPObject) {
+                const abapFiles = obj.getABAPFiles();
+                console.error(`[Consumer ${this.workerId}] [abaplint] ABAP 文件数: ${abapFiles.length}`);
+                if (abapFiles.length > 0) {
+                    const file = abapFiles[0];
+                    const fileInfo = file.getInfo();
+                    const statements = file.getStatements();
+                    // 🎯 优先检查：FUNCTION 模块（仅对此类型提取真实名称）
+                    const functionStatements = statements.filter(s => s.get() && s.get().constructor.name === 'FunctionModule');
+                    if (functionStatements.length > 0) {
+                        detectedType = 'FUNCTION';
+                        // ✅ 使用正则表达式提取函数名（支持小写、大写、混合，以及 / 命名空间）
+                        // 匹配模式：FUNCTION function_name.
+                        // SAP 函数名可以包含: 字母、数字、下划线、斜杠(/)
+                        const functionMatch = content.match(/^\s*FUNCTION\s+([a-zA-Z_/][a-zA-Z0-9_/]*)\s*\./mi);
+                        if (functionMatch && functionMatch[1]) {
+                            extractedName = functionMatch[1].toUpperCase();
+                            console.error(`[Consumer ${this.workerId}] [正则] 提取函数名: ${extractedName} (原名: ${fileName})`);
+                        }
+                        else {
+                            console.error(`[Consumer ${this.workerId}] [警告] 无法提取函数名，使用原名: ${fileName}`);
+                        }
+                        console.error(`[Consumer ${this.workerId}] [abaplint] 检测到 ${functionStatements.length} 个函数模块 -> FUNCTION: ${extractedName}`);
+                        return { type: detectedType, realName: extractedName };
+                    }
+                    // ✅ 以下类型不提取名称，保持使用原始 include 名称
+                    // 检查测试类
+                    const testClasses = fileInfo.listClassDefinitions().filter(cls => cls.isForTesting);
+                    if (testClasses.length > 0) {
+                        detectedType = 'TESTCLASSES';
+                        console.error(`[Consumer ${this.workerId}] [abaplint] 检测到测试类 -> TESTCLASSES: ${fileName}`);
+                        return { type: detectedType, realName: fileName };
+                    }
+                    // 检查类定义和实现
+                    const classDefinitions = fileInfo.listClassDefinitions();
+                    const classImplementations = fileInfo.listClassImplementations();
+                    console.error(`[Consumer ${this.workerId}] [abaplint] 类定义: ${classDefinitions.length}, 类实现: ${classImplementations.length}`);
+                    if (classDefinitions.length > 0 && classImplementations.length === 0) {
+                        detectedType = 'LOCALS_DEF';
+                        console.error(`[Consumer ${this.workerId}] [abaplint] 检测为 LOCALS_DEF: ${fileName}`);
+                        return { type: detectedType, realName: fileName };
+                    }
+                    if (classImplementations.length > 0) {
+                        detectedType = 'LOCALS_IMP';
+                        console.error(`[Consumer ${this.workerId}] [abaplint] 检测为 LOCALS_IMP: ${fileName}`);
+                        return { type: detectedType, realName: fileName };
+                    }
+                    // 检查接口定义
+                    const interfaces = fileInfo.listInterfaceDefinitions();
+                    if (interfaces.length > 0) {
+                        detectedType = 'LOCALS_DEF';
+                        console.error(`[Consumer ${this.workerId}] [abaplint] 检测到接口定义 -> LOCALS_DEF: ${fileName}`);
+                        return { type: detectedType, realName: fileName };
+                    }
+                    // 检查 FORM 子例程
+                    const forms = fileInfo.listFormDefinitions();
+                    console.error(`[Consumer ${this.workerId}] [abaplint] FORM 子例程数: ${forms.length}`);
+                    if (forms.length >= 1) {
+                        detectedType = 'SUBROUTINES';
+                        console.error(`[Consumer ${this.workerId}] [abaplint] 检测到子例程 -> SUBROUTINES: ${fileName}`);
+                        return { type: detectedType, realName: fileName };
+                    }
+                }
+            }
+            else {
+                console.error(`[Consumer ${this.workerId}] [abaplint] 无法识别为 ABAPObject`);
+            }
+            console.error(`[Consumer ${this.workerId}] [abaplint] 未检测到特殊类型 -> STANDARD: ${fileName}`);
+            return { type: 'STANDARD', realName: fileName };
+        }
+        catch (error) {
+            console.error(`[Consumer ${this.workerId}] [abaplint] 解析失败: ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                console.error(`[Consumer ${this.workerId}] [abaplint] 堆栈: ${error.stack.substring(0, 500)}`);
+            }
+            // 解析失败时返回标准类型和原始文件名
+            return { type: 'STANDARD', realName: fileName };
+        }
+    }
+    /**
+     * 根据 include 类型生成符合 abaplint 规范的文件路径
+     */
+    generateIncludeFilePath(includeName, includeType, objectRootPath) {
+        const sanitizedName = (0, common_1.sanitizeObjectName)(includeName);
+        let extension;
+        switch (includeType) {
+            case 'FUNCTION':
+                extension = 'func.abap';
+                break;
+            case 'LOCALS_DEF':
+                extension = 'clas.locals_def.abap';
+                break;
+            case 'LOCALS_IMP':
+                extension = 'clas.locals_imp.abap';
+                break;
+            case 'TESTCLASSES':
+                extension = 'clas.testclasses.abap';
+                break;
+            case 'MACROS':
+                extension = 'clas.macros.abap';
+                break;
+            case 'SCREENS':
+                extension = 'prog.screens.abap';
+                break;
+            case 'SUBROUTINES':
+                extension = 'prog.subs.abap';
+                break;
+            case 'STANDARD':
+            default:
+                extension = 'prog.abap';
+                break;
+        }
+        return join(objectRootPath, 'includes', `${sanitizedName}.${extension}`);
+    }
+    /**
+     * 提取函数组名称
+     */
+    extractFunctionGroup(cachedData) {
+        if (cachedData.ET_FUNCTION && Array.isArray(cachedData.ET_FUNCTION) && cachedData.ET_FUNCTION.length > 0) {
+            const func = cachedData.ET_FUNCTION[0];
+            return func.FUNCTIONGROUP || null;
+        }
+        return null;
+    }
+    /**
+     * 生成文件路径
+     */
+    generateFilePath(objectName, objectType, objectRootPath) {
+        const sanitizedName = (0, common_1.sanitizeObjectName)(objectName);
+        return join(objectRootPath, this.getObjectDirectory(objectType), `${sanitizedName}.${this.getDefaultExtension(objectType)}`);
+    }
+    /**
+     * 获取默认文件扩展名
+     */
+    getDefaultExtension(objectType) {
+        const extensionMap = {
+            'CLASS': 'clas.abap',
+            'FUNCTION': 'func.abap',
+            'PROGRAM': 'prog.abap',
+            'INCLUDE': 'prog.abap'
+        };
+        return extensionMap[objectType.toUpperCase()] || 'abap';
+    }
+    /**
+     * 获取对象目录
+     */
+    getObjectDirectory(objectType) {
+        const directoryMap = {
+            'CLASS': 'classes',
+            'FUNCTION': 'functions',
+            'PROGRAM': 'programs',
+            'INCLUDE': 'includes'
+        };
+        return directoryMap[objectType.toUpperCase()] || 'others';
+    }
+    /**
+     * 获取活跃的 Job 列表
+     */
+    async getActiveJobs() {
+        return await this.queueManager.getActiveJobIds();
+    }
+    /**
+     * 延迟函数
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * 处理结构体列表
+     */
+    async processStructures(structures, objectRootPath) {
+        if (!structures || structures.length === 0) {
+            return;
+        }
+        for (const structure of structures) {
+            if (!structure.TABLENAME) {
+                continue;
+            }
+            await this.processSingleStructure(structure.TABLENAME, objectRootPath);
+        }
+    }
+    /**
+     * 处理单个结构体
+     */
+    async processSingleStructure(structureName, objectRootPath) {
+        try {
+            console.error(`[Consumer ${this.workerId}] 处理结构体: ${structureName}`);
+            // 获取表结构数据
+            const tableData = await (0, generators_1.fetchTableData)(structureName);
+            if (!tableData) {
+                console.error(`[Consumer ${this.workerId}] 获取表结构数据失败: ${structureName}`);
+                return;
+            }
+            const tabClass = tableData.TABCLASS;
+            // 保存到 structures 目录
+            const structureResult = await (0, generators_1.saveStructureJson)(tableData, structureName, objectRootPath);
+            this.downloadedFiles.push({
+                objectName: structureName,
+                objectType: 'STRUCTURE',
+                filePath: structureResult.filePath || join(objectRootPath, 'structures', `${structureName}.json`),
+                success: structureResult.success,
+                error: structureResult.error
+            });
+            // 如果是透明表，额外保存到 tables 目录
+            if (tabClass === 'TRANSP') {
+                const tableResult = await (0, generators_1.saveTableJson)(tableData, structureName, objectRootPath);
+                this.downloadedFiles.push({
+                    objectName: structureName,
+                    objectType: 'TABLE',
+                    filePath: tableResult.filePath || join(objectRootPath, 'tables', `${structureName}.json`),
+                    success: tableResult.success,
+                    error: tableResult.error
+                });
+            }
+            // 处理 domain 定义
+            if (tableData.GT_FIELDS && tableData.GT_FIELDS.length > 0) {
+                await (0, generators_1.processTableDomains)(tableData.GT_FIELDS, structureName, objectRootPath, this.downloadedFiles);
+            }
+        }
+        catch (error) {
+            console.error(`[Consumer ${this.workerId}] 处理结构体失败: ${structureName} -`, error);
+        }
+    }
+    /**
+     * 处理屏幕数据
+     */
+    async processScreens(fields, flowLogic, screenDescs, programName, objectRootPath) {
+        const hasFields = fields && fields.length > 0;
+        const hasFlowLogic = flowLogic && flowLogic.length > 0;
+        const hasScreenDescs = screenDescs && screenDescs.length > 0;
+        if (!hasFields && !hasFlowLogic && !hasScreenDescs) {
+            return;
+        }
+        try {
+            console.error(`[Consumer ${this.workerId}] 处理程序 ${programName} 的屏幕数据`);
+            // 按屏幕号分组数据
+            const screenDataMap = new Map();
+            // 处理字段
+            if (hasFields) {
+                for (const field of fields) {
+                    const screenNumber = field.SCREEN;
+                    if (!screenNumber)
+                        continue;
+                    if (!screenDataMap.has(screenNumber)) {
+                        screenDataMap.set(screenNumber, {});
+                    }
+                    const data = screenDataMap.get(screenNumber);
+                    if (!data.fields) {
+                        data.fields = [];
+                    }
+                    data.fields.push(field);
+                }
+            }
+            // 处理流程逻辑
+            if (hasFlowLogic) {
+                for (const flow of flowLogic) {
+                    const screenNumber = flow.SCREEN;
+                    if (!screenNumber)
+                        continue;
+                    if (!screenDataMap.has(screenNumber)) {
+                        screenDataMap.set(screenNumber, {});
+                    }
+                    const data = screenDataMap.get(screenNumber);
+                    if (!data.flowLogic) {
+                        data.flowLogic = [];
+                    }
+                    data.flowLogic.push(flow);
+                }
+            }
+            // 处理屏幕描述
+            if (hasScreenDescs) {
+                for (const desc of screenDescs) {
+                    const screenNumber = desc.SCREEN;
+                    if (!screenNumber)
+                        continue;
+                    if (!screenDataMap.has(screenNumber)) {
+                        screenDataMap.set(screenNumber, {});
+                    }
+                    const data = screenDataMap.get(screenNumber);
+                    data.screenDesc = desc;
+                }
+            }
+            if (screenDataMap.size === 0) {
+                return;
+            }
+            // 构建 ScreenData 数组
+            const screens = [];
+            for (const [screenNumber, data] of screenDataMap) {
+                screens.push({
+                    screenNumber,
+                    programName,
+                    fields: data.fields,
+                    flowLogic: data.flowLogic,
+                    screenDesc: data.screenDesc
+                });
+            }
+            // 按屏幕号排序
+            screens.sort((a, b) => a.screenNumber.localeCompare(b.screenNumber));
+            // 生成屏幕XML文件
+            await (0, generators_1.generateMultipleScreensXml)(screens, programName, objectRootPath, this.downloadedFiles, true // 包含PROGDIR
+            );
+            console.error(`[Consumer ${this.workerId}] 程序 ${programName} 的屏幕XML生成成功`);
+        }
+        catch (error) {
+            console.error(`[Consumer ${this.workerId}] 处理屏幕失败:`, error);
+        }
+    }
+}
+exports.FileDownloadConsumer = FileDownloadConsumer;