sks-maximo-utils 1.0.7 → 1.1.0

package/CLI.md

@@ -12,6 +12,7 @@
 | `sks-maximo import-presentation <fileName>` | 导入应用XML配置 |
 | `sks-maximo import-script <fileName>` | 导入自动化脚本 |
 | `sks-maximo import-domain <fileName>` | 导入域配置 |
+| `sks-maximo import-maxintobject <fileName>` | 导入对象结构(Integration Object)配置 |
 
 ---
 
@@ -116,7 +117,7 @@ sks-maximo import-script <fileName> [-e env] [-l logname]
 sks-maximo import-domain <fileName> [-e env] [-l logname]
 ```
 
-**说明：** 导入 Maximo 域配置
+**说明：** 导入 Maximo 域配置，走 `SKS.AUTOSCRIPT.OBJECTS`（`_type=domains&_action=import`）。文件内容支持域数组 / `{domains:[...]}` / 单域对象三种格式。
 
 | 参数 | 说明 | 必填 |
 |------|------|------|
@@ -126,6 +127,22 @@ sks-maximo import-domain <fileName> [-e env] [-l logname]
 
 ---
 
+### 3.6 导入对象结构(Integration Object)
+
+```bash
+sks-maximo import-maxintobject <fileName> [-e env] [-l logname]
+```
+
+**说明：** 导入 Maximo 对象结构（发布通道），走 `SKS.AUTOSCRIPT.OBJECTS`（`_type=integrationobjects&_action=import`）。文件内容需为 `{integrationobjects:[...]}` 格式（从对象结构导出的 JSON 可直接回导）。
+
+| 参数 | 说明 | 必填 |
+|------|------|------|
+| `<fileName>` | 对象结构 JSON 文件路径 | 是 |
+| `-e` / `--env` | 指定环境（默认 local） | 否 |
+| `-l` / `--logname` | 日志打印名称 | 否 |
+
+---
+
 ## 4. 调用通用脚本接口
 
 ```bash
@@ -144,7 +161,7 @@ sks-maximo call <scriptName> [--file <fileName>] [--params <params>] [--logname
 ### 4.1 GET 请求（无请求体）
 
 ```bash
-sks-maximo call SHARPTREE.AUTOSCRIPT.LIBRARY --params '{"name":"TEST"}'
+sks-maximo call SKS.AUTOSCRIPT.LIBRARY --params '{"name":"TEST"}'
 ```
 
 ### 4.2 POST 请求（带请求体文件）
@@ -154,7 +171,7 @@ sks-maximo call SHARPTREE.AUTOSCRIPT.LIBRARY --params '{"name":"TEST"}'
 sks-maximo call SKS_DEPLOY_AUTOKEY --file data/autokey.json
 
 # XML 请求体
-sks-maximo call SHARPTREE.AUTOSCRIPT.SCREENS --file screens/test.xml
+sks-maximo call SKS.AUTOSCRIPT.SCREENS --file screens/test.xml
 
 # 同时带参数和请求体
 sks-maximo call SKS_IMP_MAXAPPINFO --file appinfo.json --params '{"debug":true}' --logname "导入应用信息"
@@ -200,7 +217,7 @@ sks-maximo call SKS_IMP_MAXAPPINFO --file appinfo.json --params '{"debug":true}'
 ### 示例 1：查询脚本库
 
 ```bash
-sks-maximo call SHARPTREE.AUTOSCRIPT.LIBRARY --params '{"name":"MY_SCRIPT"}'
+sks-maximo call SKS.AUTOSCRIPT.LIBRARY --params '{"name":"MY_SCRIPT"}'
 ```
 
 ### 示例 2：部署自动编码

package/README.md

@@ -40,7 +40,10 @@ import {
   importMaxAutoKey,
   importMaxScript,
   importMaxAppInfo,
+  importMaxIntObject,
   callMaxScript,
+  batchImport,
+  printBatchStats,
   fileUtils,
   loadConfig,
   logger
@@ -69,12 +72,32 @@ importMaxScript({ fileName: "scripts/TEST.json" });
 // 导入应用信息配置
 importMaxAppInfo({ fileName: "MAXAPPINFO/appinfo.json", logname: "应用信息" });
 
+// 导入对象结构(Integration Object): 走 SKS.AUTOSCRIPT.OBJECTS (_type=integrationobjects&_action=import)
+// body 需为 {integrationobjects:[...]} 格式(导出的 JSON 可直接回导)
+importMaxIntObject({ fileName: "DBMAXINTOBJECT/OSIBM_POISSUE.json", logname: "PO问题对象结构" });
+
 // 通用脚本接口调用（GET）
-callMaxScript({ apiScriptName: "SHARPTREE.AUTOSCRIPT.LIBRARY", params: { name: "test" }, logname: "查询脚本库" });
+callMaxScript({ apiScriptName: "SKS.AUTOSCRIPT.LIBRARY", params: { name: "test" }, logname: "查询脚本库" });
 
 // 通用脚本接口调用（POST，读取文件内容作为请求体）
 callMaxScript({ apiScriptName: "SKS_DEPLOY_AUTOKEY", fileName: "data/autokey.json", logname: "部署自动编码" });
 
+// 通用批量导入（支持对象、脚本、域、应用信息等所有导入功能）
+const stats = await batchImport({
+    dirName: "C:/Temp/hd/maxobject_backup",   // 目录名（与files二选一）
+    extFilter: ".json",                         // 扩展名过滤
+    importFn: importMaxObject,                  // 导入函数（可换成其他导入方法）
+    logname: "批量导入对象",
+    concurrency: 1                              // 并发数，默认1串行
+});
+printBatchStats(stats);  // 打印批量导入统计结果
+
+// 直接指定文件列表批量导入
+await batchImport({
+    files: ["a.json", "b.json", "c.json"],
+    importFn: importMaxDomain
+});
+
 // 文件工具
 fileUtils.listFiles('scripts', '.json');
 fileUtils.readFileContent('test.txt');
@@ -133,17 +156,21 @@ fileUtils.readFileContent('test.txt');
 | importMaxAutoKey | 导入 AutoKey 配置 |
 | importMaxScript | 导入自动化脚本（自动保存历史记录） |
 | importMaxAppInfo | 导入应用信息配置 |
+| importMaxIntObject | 导入对象结构(Integration Object)配置 |
 
 ### 其他方法
 
 | 方法 | 说明 |
 |------|------|
 | callMaxScript | 通用脚本接口调用（GET/POST） |
+| batchImport | 通用批量导入（支持对象、脚本、域、应用信息等所有导入功能） |
+| printBatchStats | 打印批量导入统计结果 |
 | loadConfig(env) | 加载指定环境配置 |
 | saveScriptHistory(options) | 保存脚本历史记录 |
 | readFileContent(fileName) | 读取文件内容 |
 | readJsonFile(fileName) | 读取并解析 JSON 文件 |
 | fileExists(fileName) | 检查文件是否存在 |
+| fileUtils.resolveFilePath(fileName) | 通用路径转换（相对/绝对路径转规范化绝对路径） |
 | fileUtils.listFiles(dirName, extFilter, recursive) | 列出目录文件 |
 | fileUtils.readFileContent(fileName) | 读取文件内容 |
 | fileUtils.readJsonFile(fileName) | 读取并解析 JSON 文件 |

package/cli.js

@@ -3,7 +3,7 @@ import { exec } from 'child_process';
 import { readFileSync } from 'fs';
 import { fileURLToPath, URL } from 'url';
 import { checkAndCreateConfig, getConfigDir, loadConfig } from './nodeutils/config.js';
-import { callMaxScript, importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, importMaxAppInfo } from './nodeutils/maximoTools.js';
+import { callMaxScript, importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, importMaxAppInfo, importMaxIntObject } from './nodeutils/maximoTools.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = new URL('.', import.meta.url).pathname;
@@ -38,6 +38,7 @@ if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
   console.log('  sks-maximo import-presentation <fileName> # 导入应用XML配置');
   console.log('  sks-maximo import-script <fileName>    # 导入自动化脚本');
   console.log('  sks-maximo import-domain <fileName>    # 导入域配置');
+  console.log('  sks-maximo import-maxintobject <fileName> # 导入对象结构(Integration Object)配置');
   console.log('');
   console.log('环境:');
   console.log('  local                   # 使用本地环境配置');
@@ -51,6 +52,7 @@ if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
   console.log('  import-presentation     # 导入应用XML配置');
   console.log('  import-script           # 导入自动化脚本');
   console.log('  import-domain           # 导入域配置');
+  console.log('  import-maxintobject     # 导入对象结构(Integration Object)配置');
   console.log('');
   console.log('选项:');
   console.log('  -h, --help              # 显示帮助信息');
@@ -271,6 +273,35 @@ if (!cmd || ['-h', '--help', '-?', '--version', '-v'].includes(cmd)) {
       process.exit(1);
     }
   })();
+} else if (cmd === 'import-maxintobject') {
+  const fileName = filteredArgs[1];
+  if (!fileName) {
+    console.error('错误: 请指定对象结构 JSON 文件路径');
+    console.log('用法: sks-maximo import-maxintobject <fileName> [-e env] [-l logname]');
+    process.exit(1);
+  }
+  let logname = null;
+  for (let i = 2; i < filteredArgs.length; i++) {
+    if (filteredArgs[i] === '--logname' || filteredArgs[i] === '-l') {
+      logname = filteredArgs[i + 1];
+      i++;
+    }
+  }
+  loadConfig(globalEnv);
+  (async () => {
+    try {
+      const result = await importMaxIntObject({ fileName, logname: logname || fileName });
+      if (result) {
+        console.log('导入成功');
+      } else {
+        console.error('导入失败');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('导入出错:', error.message);
+      process.exit(1);
+    }
+  })();
 } else {
   console.error(`不支持的命令: ${cmd}`);
   console.log('使用 sks-maximo --help 查看帮助信息');

package/index.js

@@ -3,5 +3,5 @@ export { loadConfig, getConfig, getWorkDir } from './nodeutils/config.js';
 export { default as logger } from './nodeutils/logger.js';
 export { default as request } from './nodeutils/requestHttp.js';
 export * as fileUtils from './nodeutils/fileUtils.js';
-export { importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, saveScriptHistory, importMaxAppInfo, callMaxScript, batchImport, printBatchStats } from './nodeutils/maximoTools.js';
+export { importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, saveScriptHistory, importMaxAppInfo, importMaxIntObject, callMaxScript, batchImport, printBatchStats } from './nodeutils/maximoTools.js';
 export { sendMockData, sendMockDataBatch, sendPOMockData, sendPOMockDataBatch, sendRlImportMockDataBatch } from './nodeutils/mockdataTools.js';

package/nodeutils/maximoTools.js

@@ -34,7 +34,7 @@ export async function importMaxObject({fileName, logname}) {
         // 发送请求到Maximo API
         logger.info(`[${logname}]开始发送请求...`);
         const response = await request({
-            url: '/api/script/SHARPTREE.AUTOSCRIPT.LIBRARY',
+            url: '/api/script/SKS.AUTOSCRIPT.LIBRARY',
             method: 'post',
             params: {
                 develop: true,
@@ -101,7 +101,7 @@ export async function importMaxPresentation({fileName, logname}) {
         
         logger.info(`[${logname}]开始发送请求...`);
         const response = await request({
-            url: '/api/script/SHARPTREE.AUTOSCRIPT.SCREENS',
+            url: '/api/script/SKS.AUTOSCRIPT.SCREENS',
             method: 'post',
               headers: {
                 'Content-Type': 'application/xml'
@@ -138,10 +138,41 @@ export async function importMaxPresentation({fileName, logname}) {
 }
 
 
+/**
+ * 解析 SKS.AUTOSCRIPT.OBJECTS 导入响应，统一处理字符串/对象
+ * @param {any} response
+ * @returns {Object|null}
+ */
+function parseImportResponse(response) {
+    if (response === null || response === undefined) return null;
+    if (typeof response === 'string') {
+        try { return JSON.parse(response); } catch (e) { return null; }
+    }
+    return response;
+}
+
+/**
+ * 判断 SKS.AUTOSCRIPT.OBJECTS 批量导入是否真正成功(HTTP 200 但 summary.failed>0 视为失败)
+ * @param {any} response
+ * @returns {{ok: boolean, summary: Object|null, result: Array}}
+ */
+function checkImportResult(response) {
+    const data = parseImportResponse(response);
+    if (!data || data.status !== 'success' || !data.summary) {
+        return { ok: false, summary: data ? data.summary : null, result: data ? (data.result || []) : [] };
+    }
+    const failed = data.summary.failed || 0;
+    if (failed > 0) {
+        return { ok: false, summary: data.summary, result: data.result || [] };
+    }
+    return { ok: true, summary: data.summary, result: data.result || [] };
+}
+
 /**
  * 导入Maximo域
+ * 走 SKS.AUTOSCRIPT.OBJECTS (_type=domains&_action=import), body 支持域数组 / {domains:[...]} / 单域对象
  * @param {Object} options - 配置选项
- * @param {string} options.fileName - 配置文件名（JSON或XML）
+ * @param {string} options.fileName - 配置文件名(JSON)
  * @param {string} options.logname - 日志打印名称
  * @returns {Promise<boolean>} 是否导入成功
  */
@@ -150,58 +181,114 @@ export async function importMaxDomain({fileName, logname}) {
         logname = fileName
     }
     try {
-        // 根据文件扩展名选择读取方式
         let fileContent = null;
         fileContent = readFileContent(fileName);
-        
-        // 检查文件是否成功读取
+
         if (!fileContent) {
             logger.error(`[${logname}]文件读取失败: ${fileName}`);
             return false;
         }
-        
+
         logger.info(`[${logname}]成功读取文件: ${fileName}`);
         logger.info(`[${logname}]文件大小: ${fileContent.length} 字节`);
         logger.info(`[${logname}]准备导入domain: ${logname || '未指定'}`);
-        
-        // 发送请求到Maximo API
+
         logger.info(`[${logname}]开始发送请求...`);
         const response = await request({
-            url: '/api/script/SKS_DEPLOY_DOMAIN',
+            url: '/api/script/SKS.AUTOSCRIPT.OBJECTS',
             method: 'post',
             params: {
-                develop: true,
+                _type: 'domains',
+                _action: 'import',
                 _langcode: getConfig().langcode,
             },
-            data: fileContent  // 将文件内容作为请求体发送
+            data: fileContent
         })
-        
-        logger.warn(`[${logname}]收到响应`);
-        logger.warn(`[${logname}]响应类型:`, typeof response);
-        logger.warn(`[${logname}]响应内容:`, response);
-        
-        // 检查响应 - requestHttp的响应拦截器已返回res.data
-        if (response !== null && response !== undefined) {
-            logger.warn(`[${logname}]导入成功`)
+
+        const { ok, summary, result } = checkImportResult(response);
+        if (ok) {
+            logger.warn(`[${logname}]导入成功 总计:${summary.total} 成功:${summary.success}`)
             return true
         } else {
-            logger.error(`[${logname}]导入失败，响应为空或null`)
-            logger.error(`[${logname}]响应值:`, response)
+            logger.error(`[${logname}]导入失败, 响应:`, response)
+            if (result && result.length > 0) {
+                result.filter(r => r.status === 'FAILED').forEach(r => {
+                    logger.error(`[${logname}]  - ${r.domainid || r.id || '未知'}: ${r.message}`)
+                })
+            }
+            return false
+        }
+    } catch (error) {
+        logger.error(`[${logname}]请求出错:`, error.message)
+        if (error.response) {
+            // 服务器返回了错误状态码
+        } else if (error.request) {
+            logger.error(`[${logname}]请求已发出但无响应`)
+        } else {
+            logger.error(`[${logname}]错误详情:`, error)
+        }
+        return false
+    }
+}
+
+
+/**
+ * 导入Maximo对象结构(Integration Object / 发布通道)
+ * 走 SKS.AUTOSCRIPT.OBJECTS (_type=integrationobjects&_action=import), body 为 {integrationobjects:[...]}
+ * @param {Object} options - 配置选项
+ * @param {string} options.fileName - 配置文件名(JSON)
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<boolean>} 是否导入成功
+ */
+export async function importMaxIntObject({fileName, logname}) {
+    if(!logname||logname===""||logname===null){
+        logname = fileName
+    }
+    try {
+        let fileContent = null;
+        fileContent = readFileContent(fileName);
+
+        if (!fileContent) {
+            logger.error(`[${logname}]文件读取失败: ${fileName}`);
+            return false;
+        }
+
+        logger.info(`[${logname}]成功读取文件: ${fileName}`);
+        logger.info(`[${logname}]文件大小: ${fileContent.length} 字节`);
+        logger.info(`[${logname}]准备导入对象结构: ${logname || '未指定'}`);
+
+        logger.info(`[${logname}]开始发送请求...`);
+        const response = await request({
+            url: '/api/script/SKS.AUTOSCRIPT.OBJECTS',
+            method: 'post',
+            params: {
+                _type: 'integrationobjects',
+                _action: 'import',
+                _langcode: getConfig().langcode,
+            },
+            data: fileContent
+        })
+
+        const { ok, summary, result } = checkImportResult(response);
+        if (ok) {
+            logger.warn(`[${logname}]导入成功 总计:${summary.total} 成功:${summary.success}`)
+            return true
+        } else {
+            logger.error(`[${logname}]导入失败, 响应:`, response)
+            if (result && result.length > 0) {
+                result.filter(r => r.status === 'FAILED').forEach(r => {
+                    logger.error(`[${logname}]  - ${r.intobjectname || r.id || '未知'}: ${r.message}`)
+                })
+            }
             return false
         }
     } catch (error) {
         logger.error(`[${logname}]请求出错:`, error.message)
         if (error.response) {
             // 服务器返回了错误状态码
-            // logger.error(`[${logname}]错误状态码:`, error.response.status)
-            // logger.error(`[${logname}]错误响应数据:`, error.response.data)
         } else if (error.request) {
-            // 请求已发出但没有收到响应
             logger.error(`[${logname}]请求已发出但无响应`)
-            // logger.error(`[${logname}]请求URL:`, error.request.url)
-            // logger.error(`[${logname}]请求方法:`, error.request.method)
         } else {
-            // 其他错误
             logger.error(`[${logname}]错误详情:`, error)
         }
         return false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sks-maximo-utils",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Maximo helper tools for updating table structures and data",
   "type": "module",
   "main": "index.js",