sks-maximo-utils 1.0.0

package/README.md

@@ -0,0 +1,128 @@
+# SKS Maximo Utils
+
+Maximo 表结构和数据更新工具集。
+
+## 安装
+
+### 全局安装（CLI 使用）
+```bash
+npm install -g sks-maximo-utils
+```
+
+### 项目中安装（引用使用）
+```bash
+npm install sks-maximo-utils
+```
+
+## 使用方式
+
+### CLI 命令
+
+不带参数运行，打开配置目录：
+```bash
+sks-maximo
+```
+
+带参数运行，加载指定环境配置：
+```bash
+sks-maximo local    # 使用 local 环境配置
+sks-maximo dev      # 使用 dev 环境配置
+sks-maximo hd       # 使用 hd 环境配置
+```
+
+### 在脚本中引用
+
+```javascript
+import { 
+  importMaxObject, 
+  importMaxPresentation, 
+  importMaxDomain,
+  loadConfig,
+  logger
+} from 'sks-maximo-utils';
+
+// 加载配置（可选，默认 local）
+loadConfig('local');
+
+// 导入 Maximo 对象配置
+importMaxObject({ fileName: "DBCONFIGJSON/test.json", logname: "测试" });
+
+// 导入应用 XML 配置
+importMaxPresentation({ fileName: "SCREENSXML/test.xml", logname: "应用" });
+
+// 导入域配置
+importMaxDomain({ fileName: "DBDOMAINJSON/domain.json", logname: "域" });
+```
+
+## 配置文件
+
+首次运行时，会自动在 `~/.sks/nodeutils/` 目录创建 `config.json` 配置文件。
+
+配置结构：
+```json
+{
+  "logLevel": "INFO",
+  "envs": {
+    "local": {
+      "baseUrl": "http://127.0.0.1:9080/maximo",
+      "apiKey": "your-api-key",
+      "maxauth": "",
+      "authType": "apiKey"
+    },
+    "dev": {
+      "baseUrl": "https://mdev/maximo",
+      "apiKey": "your-api-key",
+      "maxauth": "",
+      "authType": "apiKey"
+    }
+  }
+}
+```
+
+### 配置说明
+
+| 字段 | 说明 |
+|------|------|
+| logLevel | 全局日志级别：TRACE, DEBUG, INFO, WARN, ERROR, FATAL |
+| baseUrl | Maximo 服务地址 |
+| apiKey | API 认证密钥 |
+| maxauth | Maxauth 认证值 |
+| authType | 认证类型：apiKey 或 maxauth |
+
+环境配置中可单独设置 `logLevel`，优先级高于全局配置。
+
+## API
+
+### 导入方法
+
+| 方法 | 说明 |
+|------|------|
+| importMaxObject | 导入 Maximo 对象配置（JSON） |
+| importMaxPresentation | 导入应用 XML 配置 |
+| importMaxDomain | 导入域配置 |
+
+### 其他方法
+
+| 方法 | 说明 |
+|------|------|
+| loadConfig(env) | 加载指定环境配置 |
+| readFileContent(fileName) | 读取文件内容 |
+| readJsonFile(fileName) | 读取并解析 JSON 文件 |
+| fileExists(fileName) | 检查文件是否存在 |
+
+## 开发
+
+```bash
+# 安装依赖
+npm install
+
+# 本地链接（测试）
+npm link
+
+# 在其他项目中链接测试
+npm link sks-maximo-utils
+```
+
+## License
+
+ISC

package/TASK/TASK01.md

@@ -0,0 +1,13 @@
+# TASK01
+nodeutils 目录是我用来编写 js 类的脚本进行更新maximo表结构等操作的
+
+现在我想将这几个包装成全局函数,方便调用
+
+
+配置文件我想使用json放到 ~/.sks/nodeutils 目录下
+文件名是 config.json
+
+配置中的 filePath 我想在配置中去掉,获取node执行的目录
+
+
+参考 E:\devwork\ideawork\maximo91_soloncode\nodetasks\0626001.js

package/cli.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { exec } from 'child_process';
+import { checkAndCreateConfig, getConfigDir, loadConfig } from './nodeutils/config.js';
+
+const args = process.argv.slice(2);
+const env = args[0];
+
+if (!env) {
+  // 不带参数：检查配置并打开目录
+  const configPath = checkAndCreateConfig();
+  const configDir = getConfigDir();
+  
+  console.log(`配置文件位置: ${configPath}`);
+  console.log(`正在打开配置目录...`);
+  
+  // 根据操作系统打开目录
+  const platform = process.platform;
+  let command;
+  
+  if (platform === 'win32') {
+    command = `explorer "${configDir}"`;
+  } else if (platform === 'darwin') {
+    command = `open "${configDir}"`;
+  } else {
+    command = `xdg-open "${configDir}"`;
+  }
+  
+  exec(command, (error) => {
+    if (error) {
+      console.error(`打开目录失败: ${error.message}`);
+      console.log(`请手动打开: ${configDir}`);
+    }
+  });
+} else {
+  // 带参数：加载配置
+  loadConfig(env);
+}
+
+export * from './nodeutils/maximoTools.js';
+export * from './nodeutils/mockdataTools.js';
+export * from './nodeutils/fileUtils.js';
+export { default as logger } from './nodeutils/logger.js';
+export { default as request } from './nodeutils/requestHttp.js';

package/index.js

@@ -0,0 +1,7 @@
+// 主入口文件 - 导出所有工具函数
+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 { readFileContent, readJsonFile, readXmlFile, fileExists } from './nodeutils/fileUtils.js';
+export { importMaxObject, importMaxPresentation, importMaxDomain } from './nodeutils/maximoTools.js';
+export { sendMockData, sendMockDataBatch, sendPOMockData, sendPOMockDataBatch, sendRlImportMockDataBatch } from './nodeutils/mockdataTools.js';

package/nodeutils/config.js

@@ -0,0 +1,154 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import logger from './logger.js';
+
+// 获取当前模块目录
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let globalConfig = null;
+
+function getConfigPath() {
+  const homeDir = os.homedir();
+  return path.join(homeDir, '.sks', 'nodeutils', 'config.json');
+}
+
+export function getConfigDir() {
+  return path.dirname(getConfigPath());
+}
+
+// 检查配置文件是否存在，不存在则创建
+export function checkAndCreateConfig() {
+  const configPath = getConfigPath();
+  const configDir = getConfigDir();
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(configPath)) {
+    copySampleConfig(configPath);
+  }
+
+  return configPath;
+}
+
+export function loadConfig(env = null) {
+  const configPath = getConfigPath();
+
+  if (!env) {
+    const args = process.argv.slice(2);
+    env = args[0] || 'local';
+  }
+
+  try {
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    if (!fs.existsSync(configPath)) {
+      logger.warn(`配置文件不存在: ${configPath}，将复制示例配置`);
+      copySampleConfig(configPath);
+    }
+
+    const configData = fs.readFileSync(configPath, 'utf-8');
+    const allConfigs = JSON.parse(configData);
+
+    // 获取全局配置
+    const globalLogLevel = allConfigs.logLevel || 'INFO';
+
+    // 获取环境配置
+    const envs = allConfigs.envs || {};
+    const envConfig = envs[env] || envs.local || envs.dev;
+
+    if (!envConfig) {
+      throw new Error(`未找到环境 ${env} 的配置`);
+    }
+
+    // 合并配置：环境配置优先于全局配置
+    globalConfig = { ...envConfig };
+
+    // 设置默认 authType
+    if (!globalConfig.authType) {
+      globalConfig.authType = 'apiKey';
+    }
+
+    // logLevel 优先使用环境配置，否则使用全局配置
+    const logLevel = envConfig.logLevel || globalLogLevel;
+
+    // 规范化 baseUrl
+    if (globalConfig.baseUrl) {
+      globalConfig.baseUrl = globalConfig.baseUrl.replace(/\\/g, '/');
+      if (!globalConfig.baseUrl.endsWith('/')) {
+        globalConfig.baseUrl += '/';
+      }
+    }
+
+    logger.setLevel(logLevel);
+    logger.info(`[Config] 已加载配置，环境: ${env}, 日志级别: ${logLevel}`);
+
+    return globalConfig;
+  } catch (error) {
+    logger.error(`[Config] 加载配置文件失败: ${error.message}`);
+    throw error;
+  }
+}
+
+function copySampleConfig(configPath) {
+  const sampleConfigPath = path.join(__dirname, 'sample.config.json');
+
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  if (fs.existsSync(sampleConfigPath)) {
+    fs.copyFileSync(sampleConfigPath, configPath);
+    logger.info(`[Config] 已复制示例配置文件到: ${configPath}`);
+  } else {
+    // 如果 sample.config.json 不存在，创建默认配置
+    const defaultConfig = {
+      "logLevel": "INFO",
+      "envs": {
+        "local": {
+          "baseUrl": "http://127.0.0.1:9080/maximo",
+          "apiKey": "your-api-key-here",
+          "maxauth": ""
+        },
+        "dev": {
+          "baseUrl": "https://mdev/maximo",
+          "apiKey": "your-api-key-here",
+          "maxauth": ""
+        },
+        "hd": {
+          "baseUrl": "http://xxxxx:9080/maximo",
+          "apiKey": "your-api-key-here",
+          "maxauth": ""
+        }
+      }
+    };
+    fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2), 'utf-8');
+    logger.info(`[Config] 已创建默认配置文件: ${configPath}`);
+  }
+}
+
+export function getConfig() {
+  if (!globalConfig) {
+    return loadConfig();
+  }
+  return globalConfig;
+}
+
+export function getWorkDir() {
+  return process.cwd();
+}
+
+export default {
+  loadConfig,
+  getConfig,
+  getWorkDir,
+  getConfigDir,
+  checkAndCreateConfig
+};

package/nodeutils/fileUtils.js

@@ -0,0 +1,96 @@
+import fs from 'fs';
+import path from 'path';
+import { getWorkDir } from './config.js';
+
+/**
+ * 根据文件名获取文件路径
+ * @param {string} fileNameIn - 文件名（可以是相对路径或绝对路径）
+ * @returns {string} 文件路径
+ */
+function filePathForName(fileNameIn) {
+  var fileName = fileNameIn.replace(/\\/g, '/');
+
+  // 如果是绝对路径，直接返回
+  if (path.isAbsolute(fileName)) {
+    return fileName;
+  }
+
+  // 如果是相对路径，使用当前工作目录
+  const workDir = getWorkDir();
+  return path.join(workDir, fileName);
+}
+
+/**
+ * 根据文件名读取文件内容
+ * @param {string} fileName - 文件名（可以是相对路径或绝对路径）
+ * @param {string} encoding - 文件编码，默认 'utf-8'
+ * @returns {string|null} 文件内容，如果文件不存在返回 null
+ */
+function readFileContent(fileName, encoding = 'utf-8') {
+  const filePath = filePathForName(fileName);
+  try {
+    // 读取文件内容
+    const content = fs.readFileSync(filePath, encoding);
+    return content;
+  } catch (error) {
+    console.error(`读取文件失败: ${fileName}`, error.message);
+    return null;
+  }
+}
+
+/**
+ * 根据文件名读取JSON文件并解析
+ * @param {string} fileName - JSON文件名
+ * @returns {object|null} 解析后的JSON对象，如果失败返回 null
+ */
+function readJsonFile(fileName) {
+  const content = readFileContent(fileName);
+  try {
+    if (!content) {
+      return null;
+    }
+    const jsonData = JSON.parse(content);
+    return jsonData;
+  } catch (error) {
+    console.error(`解析JSON文件失败: ${fileName}`, error.message);
+    return null;
+  }
+}
+
+/**
+ * 根据文件名读取XML文件
+ * @param {string} fileName - XML文件名
+ * @returns {string|null} XML文件内容
+ */
+function readXmlFile(fileName) {
+  return readFileContent(fileName, 'utf-8');
+}
+
+/**
+ * 检查文件是否存在
+ * @param {string} fileNameIn - 文件名
+ * @returns {boolean} 文件是否存在
+ */
+function fileExists(fileNameIn) {
+  try {
+    var fileName = fileNameIn.replace(/\\/g, '/');
+
+    // 如果是绝对路径，直接检查
+    if (path.isAbsolute(fileName)) {
+      return fs.existsSync(fileName);
+    }
+
+    // 如果是相对路径，使用当前工作目录
+    const filePath = path.join(getWorkDir(), fileName);
+    return fs.existsSync(filePath);
+  } catch (error) {
+    return false;
+  }
+}
+
+export {
+  readFileContent,
+  readJsonFile,
+  readXmlFile,
+  fileExists
+};

package/nodeutils/logger.js

@@ -0,0 +1,57 @@
+// logger.js
+const LEVELS = {
+  TRACE: 0,
+  DEBUG: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  FATAL: 5
+};
+
+class ConsoleLogger {
+  constructor(level = 'INFO') {
+    this.level = LEVELS[level] !== undefined ? LEVELS[level] : LEVELS.INFO;
+  }
+
+  // 设置日志级别
+  setLevel(level) {
+    if (LEVELS[level] !== undefined) {
+      this.level = LEVELS[level];
+    } else {
+      console.warn(`无效的日志级别: ${level}，保持当前级别`);
+    }
+  }
+
+  // 核心打印方法
+  _print(levelName, levelValue, args) {
+    if (levelValue < this.level) return;
+
+    const timestamp = new Date().toLocaleTimeString();
+    const prefix = `[${timestamp}] [${levelName}]`;
+
+    switch (levelValue) {
+      case LEVELS.TRACE:
+      case LEVELS.DEBUG:
+      case LEVELS.INFO:
+        console.log(prefix, ...args);
+        break;
+      case LEVELS.WARN:
+        console.warn(prefix, ...args); // 输出到 stderr，但通常显示为黄色警告
+        break;
+      case LEVELS.ERROR:
+      case LEVELS.FATAL:
+        console.error(prefix, ...args); // 输出到 stderr，通常显示为红色错误
+        break;
+    }
+  }
+
+  trace(...args) { this._print('TRACE', LEVELS.TRACE, args); }
+  debug(...args) { this._print('DEBUG', LEVELS.DEBUG, args); }
+  info(...args)  { this._print('INFO', LEVELS.INFO, args); }
+  warn(...args)  { this._print('WARN', LEVELS.WARN, args); }
+  error(...args) { this._print('ERROR', LEVELS.ERROR, args); }
+  fatal(...args) { this._print('FATAL', LEVELS.FATAL, args); }
+}
+
+const logger = new ConsoleLogger('INFO'); // 默认导出一个实例，级别为 INFO
+export default logger

package/nodeutils/maximoTools.js

@@ -0,0 +1,206 @@
+import request from '../nodeutils/requestHttp.js'
+import { readFileContent, readJsonFile, readXmlFile } from './fileUtils.js'
+import logger from './logger.js';
+
+/**
+ * 导入Maximo对象配置
+ * @param {Object} options - 配置选项
+ * @param {string} options.fileName - 配置文件名（JSON或XML）
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<boolean>} 是否导入成功
+ */
+export async function importMaxObject({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 || '未指定'}`);
+        
+        // 发送请求到Maximo API
+        logger.info(`[${logname}]开始发送请求...`);
+        const response = await request({
+            url: '/api/script/SHARPTREE.AUTOSCRIPT.LIBRARY',
+            method: 'post',
+            params: {
+                develop: true,
+                _langcode: 'zh',
+            },
+            data: fileContent  // 将文件内容作为请求体发送
+        })
+        
+        logger.info(`[${logname}]收到响应`);
+        logger.info(`[${logname}]响应类型:`, typeof response);
+        logger.info(`[${logname}]响应内容:`, response);
+        
+        // 检查响应 - requestHttp的响应拦截器已返回res.data
+        if (response !== null && response !== undefined) {
+            logger.warn(`[${logname}]导入成功`)
+            return true
+        } else {
+            logger.error(`[${logname}]导入失败，响应为空或null`)
+            logger.error(`[${logname}]响应值:`, response)
+            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
+    }
+}
+
+
+/**
+ * 导入应用XML配置到Maximo
+ * @param {Object} options - 配置选项
+ * @param {string} options.fileName - XML配置文件名
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<boolean>} 是否导入成功
+ */
+export async function importMaxPresentation({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}]开始发送请求...`);
+        const response = await request({
+            url: '/api/script/SHARPTREE.AUTOSCRIPT.SCREENS',
+            method: 'post',
+              headers: {
+                'Content-Type': 'application/xml'
+            },
+            params: {
+                _langcode: 'zh',
+            },
+            data: fileContent
+        })
+        
+        logger.info(`[${logname}]收到响应`);
+        logger.info(`[${logname}]响应类型:`, typeof response);
+        logger.info(`[${logname}]响应内容:`, response);
+        
+        if (response !== null && response !== undefined) {
+            logger.warn(`[${logname}]导入成功`)
+            return true
+        } else {
+            logger.error(`[${logname}]导入失败，响应为空或null`)
+            logger.error(`[${logname}]响应值:`, response)
+            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域
+ * @param {Object} options - 配置选项
+ * @param {string} options.fileName - 配置文件名（JSON或XML）
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<boolean>} 是否导入成功
+ */
+export async function importMaxDomain({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}]准备导入domain: ${logname || '未指定'}`);
+        
+        // 发送请求到Maximo API
+        logger.info(`[${logname}]开始发送请求...`);
+        const response = await request({
+            url: '/api/script/SKS_DEPLOY_DOMAIN',
+            method: 'post',
+            params: {
+                develop: true,
+                _langcode: 'zh',
+            },
+            data: fileContent  // 将文件内容作为请求体发送
+        })
+        
+        logger.info(`[${logname}]收到响应`);
+        logger.info(`[${logname}]响应类型:`, typeof response);
+        logger.info(`[${logname}]响应内容:`, response);
+        
+        // 检查响应 - requestHttp的响应拦截器已返回res.data
+        if (response !== null && response !== undefined) {
+            logger.warn(`[${logname}]导入成功`)
+            return true
+        } else {
+            logger.error(`[${logname}]导入失败，响应为空或null`)
+            logger.error(`[${logname}]响应值:`, response)
+            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/nodeutils/mockdataTools.js

@@ -0,0 +1,264 @@
+import request from '../nodeutils/requestHttp.js'
+import { readJsonFile } from './fileUtils.js'
+
+/**
+ * 发送mock数据到TEST_MOCKDATA_ITEMA接口
+ * @param {Object} options - 配置选项
+ * @param {string} options.fileName - mock数据JSON文件名（相对于项目根目录或绝对路径）
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<boolean>} 是否发送成功
+ */
+export async function sendMockData({fileName, logname="mockdata"}) {
+    try {
+        // 读取JSON文件
+        const jsonData = readJsonFile(fileName);
+        
+        if (!jsonData) {
+            console.error(`[${logname}]JSON文件读取/解析失败: ${fileName}`);
+            return false;
+        }
+        
+        console.log(`[${logname}]成功读取文件: ${fileName}`);
+        console.log(`[${logname}]申请单号: ${jsonData.APPLYNUM || 'N/A'}`);
+        console.log(`[${logname}]明细行数: ${(jsonData.IBM_ITEM_APPLYLINE && jsonData.IBM_ITEM_APPLYLINE.length) || 0}`);
+        
+        // 发送请求到TEST_MOCKDATA_ITEMA接口
+        console.log(`[${logname}]开始发送请求...`);
+        const response = await request({
+            url: '/api/script/TEST_MOCKDATA_ITEMA',
+            method: 'post',
+            data: jsonData  // 将JSON对象作为requestBody传入脚本
+        })
+        
+        console.log(`[${logname}]收到响应`);
+        console.log(`[${logname}]响应类型:`, typeof response);
+        console.log(`[${logname}]响应内容:`, response);
+        
+        // 检查响应
+        if (response !== null && response !== undefined) {
+            console.log(`[${logname}]发送成功`)
+            return true
+        } else {
+            console.error(`[${logname}]发送失败，响应为空或null`)
+            console.error(`[${logname}]响应值:`, response)
+            return false
+        }
+    } catch (error) {
+        console.error(`[${logname}]请求出错:`, error.message)
+        if (error.response) {
+            console.error(`[${logname}]错误状态码:`, error.response.status)
+            console.error(`[${logname}]错误响应数据:`, error.response.data)
+        } else if (error.request) {
+            console.error(`[${logname}]请求已发出但无响应`)
+        } else {
+            console.error(`[${logname}]错误详情:`, error)
+        }
+        return false
+    }
+}
+
+/**
+ * 批量发送mock数据（遍历指定目录下的所有JSON文件，或指定文件列表）
+ * @param {Object} options - 配置选项
+ * @param {string[]} options.files - mock数据JSON文件名列表
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<{total: number, success: number, fail: number}>} 统计结果
+ */
+export async function sendMockDataBatch({files, logname="mockdata"}) {
+    const result = { total: files.length, success: 0, fail: 0 };
+    
+    for (let i = 0; i < files.length; i++) {
+        const fileName = files[i];
+        console.log(`\n========== [${logname}] 第 ${i + 1}/${files.length} 个 ==========`);
+        console.log(`[${logname}]文件: ${fileName}`);
+        
+        const ok = await sendMockData({fileName, logname});
+        if (ok) {
+            result.success++;
+        } else {
+            result.fail++;
+        }
+    }
+    
+    console.log(`\n========== [${logname}] 批量导入完成 ==========`);
+    console.log(`[${logname}]总计: ${result.total}, 成功: ${result.success}, 失败: ${result.fail}`);
+    
+    return result;
+}
+
+/**
+ * 发送PO mock数据到MXPO OSLC API
+ * @param {Object} options - 配置选项
+ * @param {string} options.fileName - mock数据JSON文件名（包含PO数组）
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<{total: number, success: number, fail: number}>} 统计结果
+ */
+export async function sendPOMockData({fileName, logname="PO"}) {
+    try {
+        const jsonData = readJsonFile(fileName);
+        if (!jsonData || !Array.isArray(jsonData)) {
+            console.error(`[${logname}]JSON文件读取/解析失败或格式非数组: ${fileName}`);
+            return { total: 0, success: 0, fail: 0 };
+        }
+        
+        console.log(`[${logname}]成功读取文件: ${fileName}, 共 ${jsonData.length} 个PO`);
+        
+        const result = { total: jsonData.length, success: 0, fail: 0 };
+        
+        for (let i = 0; i < jsonData.length; i++) {
+            const po = jsonData[i];
+            console.log(`\n--- [${logname}] PO ${i + 1}/${jsonData.length} ---`);
+            console.log(`[${logname}]VENDOR: ${po['spi:vendor']}, DESCRIPTION: ${po['spi:description']}`);
+            console.log(`[${logname}]POLINE数: ${(po['spi:poline'] && po['spi:poline'].length) || 0}`);
+            
+            try {
+                console.log(`[${logname}]开始发送请求...`);
+                const response = await request({
+                    url: '/api/os/MXPO',
+                    method: 'post',
+                    data: po
+                });
+                
+                console.log(`[${logname}]响应:`, response);
+                result.success++;
+            } catch (error) {
+                console.error(`[${logname}]PO创建失败:`, error.message);
+                if (error.response) {
+                    console.error(`[${logname}]错误状态码:`, error.response.status);
+                    console.error(`[${logname}]错误响应:`, error.response.data);
+                }
+                result.fail++;
+            }
+        }
+        
+        console.log(`\n[${logname}]文件 ${fileName} 处理完成: 成功 ${result.success}, 失败 ${result.fail}`);
+        return result;
+    } catch (error) {
+        console.error(`[${logname}]处理文件出错:`, error.message);
+        return { total: 0, success: 0, fail: 0 };
+    }
+}
+
+/**
+ * 批量发送PO mock数据
+ * @param {Object} options - 配置选项
+ * @param {string[]} options.files - mock数据JSON文件名列表
+ * @param {string} options.logname - 日志打印名称
+ * @returns {Promise<{total: number, success: number, fail: number}>} 统计结果
+ */
+export async function sendPOMockDataBatch({files, logname="PO"}) {
+    const result = { total: 0, success: 0, fail: 0 };
+    
+    for (let i = 0; i < files.length; i++) {
+        const fileName = files[i];
+        console.log(`\n========== [${logname}] 文件 ${i + 1}/${files.length} ==========`);
+        
+        const r = await sendPOMockData({fileName, logname});
+        result.total += r.total;
+        result.success += r.success;
+        result.fail += r.fail;
+    }
+    
+    console.log(`\n========== [${logname}] 全部完成 ==========`);
+    console.log(`[${logname}]总计: ${result.total}, 成功: ${result.success}, 失败: ${result.fail}`);
+    
+    return result;
+}
+
+/**
+ * 批量发送RL_IMPORT mock数据到TEST_MOCKDATA_RLIMPORT脚本接口
+ * @param {Object} options - 配置选项
+ * @param {number} options.loopCount - 循环调用次数，默认1
+ * @param {number} options.rlCount - 每次调用创建的IBM_RL主表记录数，默认5
+ * @param {number} options.minImportsPerRL - 每条主表最少子表记录数，默认100
+ * @param {number} options.maxImportsPerRL - 每条主表最多子表记录数，默认500
+ * @param {number} options.apprPercent - STATUS=APPR的比例(%)，默认90
+ * @param {string} options.logname - 日志打印名称，默认RL_IMPORT
+ * @returns {Promise<{loopCount: number, totalRL: number, totalImports: number, success: number, fail: number}>} 统计结果
+ */
+export async function sendRlImportMockDataBatch({
+    loopCount = 1,
+    rlCount = 5,
+    minImportsPerRL = 100,
+    maxImportsPerRL = 500,
+    apprPercent = 90,
+    logname = "RL_IMPORT"
+} = {}) {
+    const result = {
+        loopCount,
+        totalRL: 0,
+        totalImports: 0,
+        success: 0,
+        fail: 0
+    };
+
+    const body = {
+        rlCount,
+        minImportsPerRL,
+        maxImportsPerRL,
+        apprPercent
+    };
+
+    console.log(`\n========== [${logname}] 开始批量生成 ==========`);
+    console.log(`[${logname}]循环次数: ${loopCount}, 每次创建${rlCount}条IBM_RL`);
+    console.log(`[${logname}]每条主表子表数: ${minImportsPerRL}~${maxImportsPerRL}`);
+    console.log(`[${logname}]APPR比例: ${apprPercent}% (REQSOURCE/RLTYPE/PARTTYPE由脚本随机取域值)`);
+    console.log(`[${logname}]预计总IBM_RL: ${loopCount * rlCount} 条`);
+    console.log(`[${logname}]预计总IBM_RLIMPORT: ${loopCount * rlCount * Math.floor((minImportsPerRL + maxImportsPerRL) / 2)} 条(估算)`);
+
+    const startTime = Date.now();
+
+    for (let i = 0; i < loopCount; i++) {
+        console.log(`\n--- [${logname}] 第 ${i + 1}/${loopCount} 次调用 ---`);
+        try {
+            const response = await request({
+                url: '/api/script/TEST_MOCKDATA_RLIMPORT',
+                method: 'post',
+                data: body
+            });
+
+            if (response !== null && response !== undefined) {
+                // 解析脚本返回的统计信息
+                let parsed = null;
+                try {
+                    parsed = (typeof response === 'string') ? JSON.parse(response) : response;
+                } catch (parseErr) {
+                    parsed = null;
+                }
+
+                if (parsed && parsed.status === 'success') {
+                    const rlCreated = parsed.rlCount || rlCount;
+                    const importsCreated = parsed.totalImports || 0;
+                    result.totalRL += rlCreated;
+                    result.totalImports += importsCreated;
+                    result.success++;
+                    console.log(`[${logname}]成功: RL=${rlCreated}, IMPORT=${importsCreated}, APPR=${parsed.apprCount || '?'}, DRAFT=${parsed.draftCount || '?'}`);
+                } else {
+                    result.success++;
+                    result.totalRL += rlCount;
+                    console.log(`[${logname}]成功(响应无统计): 按默认${rlCount}条RL计算`);
+                    console.log(`[${logname}]响应:`, response);
+                }
+            } else {
+                result.fail++;
+                console.error(`[${logname}]第${i + 1}次调用失败，响应为空`);
+            }
+        } catch (error) {
+            result.fail++;
+            console.error(`[${logname}]第${i + 1}次调用出错:`, error.message);
+            if (error.response) {
+                console.error(`[${logname}]错误状态码:`, error.response.status);
+                console.error(`[${logname}]错误响应:`, error.response.data);
+            }
+        }
+    }
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(`\n========== [${logname}] 批量生成完成 ==========`);
+    console.log(`[${logname}]循环次数: ${loopCount}, 成功: ${result.success}, 失败: ${result.fail}`);
+    console.log(`[${logname}]总IBM_RL: ${result.totalRL} 条`);
+    console.log(`[${logname}]总IBM_RLIMPORT: ${result.totalImports} 条`);
+    console.log(`[${logname}]耗时: ${elapsed} 秒`);
+
+    return result;
+}

package/nodeutils/requestHttp.js

@@ -0,0 +1,159 @@
+import http from 'http';
+import https from 'https';
+import axios from 'axios';
+import { getConfig } from './config.js';
+import logger from './logger.js';
+
+// 完全禁用 TLS 证书验证（仅用于开发环境）
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+
+/**
+ * 限制日志输出长度
+ * @param {any} data 要输出的数据
+ * @param {number} [maxLength=200] 最大长度，默认 200
+ * @returns {{truncated: boolean, data: string}} true 表示未超出限制，false 表示已截断
+ */
+function limitLogOutput(data, maxLength = 200) {
+  const str = typeof data === 'string' ? data : JSON.stringify(data);
+
+  if (str.length <= maxLength) {
+    return { truncated: false, data: str };
+  } else {
+    const truncated = str.substring(0, maxLength) + `...(${str.length}个字)`;
+    return { truncated: true, data: truncated };
+  }
+}
+
+// 创建axios实例
+function createService() {
+  const config = getConfig();
+  const service = axios.create({
+    baseURL: config.baseUrl,
+    timeout: 50000,
+    headers: {
+      'User-Agent': 'RequestHttp'
+    },
+    noAuth: false,
+    authType: 'apiKey',
+  });
+
+  // request拦截器
+  service.interceptors.request.use(config => {
+    const globalConfig = getConfig();
+    logger.info('[Request] 开始处理请求');
+    logger.info('[Request] URL:', config.url);
+    logger.info('[Request] Method:', config.method);
+
+    // 是否需要设置 token
+    if (!config.noAuth) {
+      if (config.authType == 'apiKey') {
+        config.headers['apiKey'] = globalConfig.apiKey;
+        logger.info('[Request] 设置 apiKey');
+      } else {
+        if (config.maxauth) {
+          config.headers['maxauth'] = globalConfig.maxauth;
+          logger.info('[Request] 设置 maxauth');
+        }
+      }
+    }
+
+    if (!config.headers['Content-Type']) config.headers['Content-Type'] = 'application/json;charset=utf-8';
+    if (!config.headers['Accept']) config.headers['Accept'] = '*/*';
+    if (!config.params) {
+      config.params = {};
+    }
+    if (!(config.url.concat('_langcode') || config.params['_langcode'])) {
+      config.params['_langcode'] = 'zh';
+    }
+    var url = `${config.method} ${globalConfig.baseUrl}${config.url}`;
+    if (config.params && Object.keys(config.params).length > 0) {
+      if (url.indexOf('?') > -1) {
+        url += `&`;
+      } else {
+        url += `?`;
+      }
+      url += `${Object.entries(config.params).map(([key, value]) => `${key}=${value}`).join('&')}`;
+    }
+    let httpContent = `### ${url}\n`;
+    httpContent += `${url}\n`;
+    // 添加 headers（过滤掉一些自动添加的头）
+    const skipHeaders = ['user-agent', 'content-length', 'host', 'accept-encoding', 'connection'];
+    Object.entries(config.headers || {}).forEach(([key, value]) => {
+      const lowerKey = key.toLowerCase();
+      if (!skipHeaders.includes(lowerKey)) {
+        httpContent += `${key}: ${value}\n`;
+      }
+    });
+    if (config.data) {
+      httpContent += `### Request Data\n${limitLogOutput(config.data).data}\n`;
+    }
+    logger.info(httpContent);
+    logger.info('[Request] 请求准备完成，发送请求...');
+    return config;
+  }, error => {
+    logger.debug(error);
+    Promise.reject(error);
+  });
+
+  // 响应拦截器
+  service.interceptors.response.use(res => {
+    logger.info('[Response] 收到响应，状态码:', res.status);
+    logger.info('[Response] 响应数据:', res.data);
+
+    // 未设置状态码则默认成功状态
+    const code = res.data?.code || res.status || 200;
+    if (code >= 200 && code < 300) {
+      return res.data;
+    }
+
+    // 处理各种错误状态码
+    logger.error('[Response] 请求失败，状态码:', code);
+    if (code === 401) {
+      logger.error("无效的token");
+      return Promise.reject(new Error('无效的token'));
+    } else if (code === 500) {
+      logger.error("服务器内部错误");
+      return Promise.reject(new Error(res.data?.message || '服务器内部错误'));
+    } else if (code > 200) {
+      return Promise.reject(new Error(res.data?.message || `请求失败，状态码: ${code}`));
+    } else {
+      return Promise.reject(new Error('未知错误'));
+    }
+  }, error => {
+    logger.error('[Response Error] 请求错误:', error.message);
+    logger.debug('[Response Error] 错误对象:', error);
+
+    let { message } = error;
+    if (message == "Network Error") {
+      message = "后端接口连接异常";
+    }
+    else if (message.includes("timeout")) {
+      message = "系统接口请求超时";
+    }
+    else if (message.includes("Request failed with status code")) {
+      let code = message.substr(message.length - 3);
+      if (code == '502') {
+        message = "系统正在维护,请稍后再试";
+      } else {
+        message = "系统接口" + code + "异常";
+      }
+    }
+    logger.error('[Response Error] 错误信息:', message);
+    return Promise.reject(error);
+  });
+
+  return service;
+}
+
+// 延迟创建 service，确保配置已加载
+let service = null;
+function getService() {
+  if (!service) {
+    service = createService();
+  }
+  return service;
+}
+
+// 默认导出函数
+const requestFn = (config) => getService()(config);
+export default requestFn;

package/nodeutils/sample.config.json

@@ -0,0 +1,23 @@
+{
+  "logLevel": "INFO",
+  "envs": {
+    "local": {
+      "baseUrl": "http://127.0.0.1:9080/maximo",
+      "apiKey": "your-local-api-key",
+      "maxauth": "",
+      "authType": "apiKey"
+    },
+    "dev": {
+      "baseUrl": "https://mdev/maximo",
+      "apiKey": "your-dev-api-key",
+      "maxauth": "",
+      "authType": "apiKey"
+    },
+    "hd": {
+      "baseUrl": "http://xxxxx:9080/maximo",
+      "apiKey": "your-hd-api-key",
+      "maxauth": "",
+      "authType": "apiKey"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "sks-maximo-utils",
+  "version": "1.0.0",
+  "description": "Maximo helper tools for updating table structures and data",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "sks-maximo": "cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["maximo", "sks"],
+  "author": "shoukaiseki",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.6.0"
+  }
+}