sks-maximo-utils 1.0.3 → 1.0.4

package/README.md

@@ -38,6 +38,8 @@ import {
   importMaxPresentation, 
   importMaxDomain,
   importMaxAutoKey,
+  importMaxScript,
+  importMaxAppInfo,
   loadConfig,
   logger
 } from 'shoukaiseki-maximo-utils';
@@ -56,6 +58,14 @@ importMaxDomain({ fileName: "DBDOMAINJSON/domain.json", logname: "域" });
 
 // 导入 AutoKey 配置
 importMaxAutoKey({ fileName: "AUTOKEYJSON/autokey.json", logname: "自动编码" });
+
+// 导入自动化脚本（自动保存历史记录）
+// fileName为JSON配置文件，同目录下需有同名.js文件
+// 例如：scripts/TEST.json 和 scripts/TEST.js
+importMaxScript({ fileName: "scripts/TEST.json" });
+
+// 导入应用信息配置
+importMaxAppInfo({ fileName: "MAXAPPINFO/appinfo.json", logname: "应用信息" });
 ```
 
 ## 配置文件
@@ -66,18 +76,21 @@ importMaxAutoKey({ fileName: "AUTOKEYJSON/autokey.json", logname: "自动编码"
 ```json
 {
   "logLevel": "INFO",
+  "langcode": "zh",
   "envs": {
     "local": {
       "baseUrl": "http://127.0.0.1:9080/maximo",
       "apiKey": "your-api-key",
       "maxauth": "",
-      "authType": "apiKey"
+      "authType": "apiKey",
+      "langcode": "zh"
     },
     "dev": {
       "baseUrl": "https://mdev/maximo",
       "apiKey": "your-api-key",
       "maxauth": "",
-      "authType": "apiKey"
+      "authType": "apiKey",
+      "langcode": "zh"
     }
   }
 }
@@ -88,12 +101,13 @@ importMaxAutoKey({ fileName: "AUTOKEYJSON/autokey.json", logname: "自动编码"
 | 字段 | 说明 |
 |------|------|
 | logLevel | 全局日志级别：TRACE, DEBUG, INFO, WARN, ERROR, FATAL |
+| langcode | 全局语言代码，默认 zh |
 | baseUrl | Maximo 服务地址 |
 | apiKey | API 认证密钥 |
 | maxauth | Maxauth 认证值 |
 | authType | 认证类型：apiKey 或 maxauth |
 
-环境配置中可单独设置 `logLevel`，优先级高于全局配置。
+环境配置中可单独设置 `logLevel` 和 `langcode`，优先级高于全局配置。
 
 ## API
 
@@ -105,16 +119,25 @@ importMaxAutoKey({ fileName: "AUTOKEYJSON/autokey.json", logname: "自动编码"
 | importMaxPresentation | 导入应用 XML 配置 |
 | importMaxDomain | 导入域配置 |
 | importMaxAutoKey | 导入 AutoKey 配置 |
+| importMaxScript | 导入自动化脚本（自动保存历史记录） |
+| importMaxAppInfo | 导入应用信息配置 |
 
 ### 其他方法
 
 | 方法 | 说明 |
 |------|------|
 | loadConfig(env) | 加载指定环境配置 |
+| saveScriptHistory(options) | 保存脚本历史记录 |
 | readFileContent(fileName) | 读取文件内容 |
 | readJsonFile(fileName) | 读取并解析 JSON 文件 |
 | fileExists(fileName) | 检查文件是否存在 |
 
+### 日志文件
+
+请求和响应日志会自动保存到 `~/.sks/nodeutils/logs/` 目录：
+- `request-*.http` - 请求日志（IntelliJ IDEA HTTP Client 格式）
+- `response-*.json` - 响应日志
+
 ## 开发
 
 ```bash

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 { readFileContent, readJsonFile, readXmlFile, fileExists } from './nodeutils/fileUtils.js';
-export { importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey } from './nodeutils/maximoTools.js';
+export { importMaxObject, importMaxPresentation, importMaxDomain, importMaxAutoKey, importMaxScript, saveScriptHistory, importMaxAppInfo } from './nodeutils/maximoTools.js';
 export { sendMockData, sendMockDataBatch, sendPOMockData, sendPOMockDataBatch, sendRlImportMockDataBatch } from './nodeutils/mockdataTools.js';

package/nodeutils/config.js

@@ -77,6 +77,10 @@ export function loadConfig(env = null) {
 
     // logLevel 优先使用环境配置，否则使用全局配置
     const logLevel = envConfig.logLevel || globalLogLevel;
+    
+    // langcode 优先使用环境配置，否则使用全局配置，默认 zh
+    const langcode = envConfig.langcode || allConfigs.langcode || 'zh';
+    globalConfig.langcode = langcode;
 
     // 规范化 baseUrl
     if (globalConfig.baseUrl) {
@@ -111,19 +115,23 @@ function copySampleConfig(configPath) {
     // 如果 sample.config.json 不存在，创建默认配置
     const defaultConfig = {
       "logLevel": "INFO",
+      "langcode": "zh",
       "envs": {
         "local": {
           "baseUrl": "http://127.0.0.1:9080/maximo",
+          "langcode": "zh",
           "apiKey": "your-api-key-here",
           "maxauth": ""
         },
         "dev": {
           "baseUrl": "https://mdev/maximo",
+          "langcode": "zh",
           "apiKey": "your-api-key-here",
           "maxauth": ""
         },
         "hd": {
           "baseUrl": "http://xxxxx:9080/maximo",
+          "langcode": "zh",
           "apiKey": "your-api-key-here",
           "maxauth": ""
         }

package/nodeutils/maximoTools.js

@@ -1,6 +1,8 @@
 import request from '../nodeutils/requestHttp.js'
 import { readFileContent, readJsonFile, readXmlFile } from './fileUtils.js'
 import logger from './logger.js';
+import { getConfig } from './config.js';
+import os from 'os'
 
 /**
  * 导入Maximo对象配置
@@ -35,7 +37,7 @@ export async function importMaxObject({fileName, logname}) {
             method: 'post',
             params: {
                 develop: true,
-                _langcode: 'zh',
+                _langcode: getConfig().langcode,
             },
             data: fileContent  // 将文件内容作为请求体发送
         })
@@ -104,7 +106,7 @@ export async function importMaxPresentation({fileName, logname}) {
                 'Content-Type': 'application/xml'
             },
             params: {
-                _langcode: 'zh',
+                _langcode: getConfig().langcode,
             },
             data: fileContent
         })
@@ -168,7 +170,7 @@ export async function importMaxDomain({fileName, logname}) {
             method: 'post',
             params: {
                 develop: true,
-                _langcode: 'zh',
+                _langcode: getConfig().langcode,
             },
             data: fileContent  // 将文件内容作为请求体发送
         })
@@ -206,6 +208,286 @@ export async function importMaxDomain({fileName, logname}) {
 }
 
 
+/**
+ * 保存脚本历史记录
+ * @param {Object} options - 配置选项
+ * @param {string} options.autoscript - 脚本名称
+ * @param {string} options.source - 脚本内容
+ * @param {string} options.version - 版本号
+ * @param {string} options.aliasname - 别名
+ * @param {string} options.hostname - 主机名
+ * @returns {Promise<boolean>} 是否保存成功
+ */
+export async function saveScriptHistory({autoscript, source, version = '', aliasname = '', hostname = ''}) {
+    try {
+        logger.info(`[${autoscript}]保存脚本历史记录...`);
+        
+        const response = await request({
+            url: '/api/script/SKS_AUTOSCRIPT_HISTORY_SAVE',
+            method: 'post',
+            params: {
+                _langcode: getConfig().langcode,
+            },
+            data: {
+                autoscript,
+                source,
+                version,
+                aliasname,
+                hostname
+            }
+        });
+        
+        logger.info(`[${autoscript}]脚本历史记录保存成功`);
+        return response !== null && response !== undefined;
+    } catch (error) {
+        logger.error(`[${autoscript}]保存脚本历史记录失败:`, error.message);
+        return false;
+    }
+}
+
+
+/**
+ * 导入Maximo自动化脚本（1:1还原插件工具箱导入流程）
+ * @param {Object} options - 配置选项
+ * @param {string} options.fileName - JSON配置文件名（同目录下需有同名.js或.py文件）
+ * @param {string} options.logname - 日志打印名称（可选，默认使用autoscript值）
+ * @returns {Promise<boolean>} 是否导入成功
+ */
+export async function importMaxScript({fileName, logname}) {
+    try {
+        const jsonContent = readJsonFile(fileName);
+        
+        if (!jsonContent) {
+            logger.error(`文件读取失败: ${fileName}`);
+            return false;
+        }
+        
+        const requiredFields = ['autoscript', 'description', 'scriptlanguage'];
+        const missingFields = requiredFields.filter(field => !jsonContent[field]);
+        if (missingFields.length > 0) {
+            logger.error(`配置文件缺少必需字段: ${missingFields.join(', ')}`);
+            return false;
+        }
+        
+        const autoscript = jsonContent.autoscript;
+        const scriptLanguage = jsonContent.scriptlanguage.toLowerCase();
+        const isPython = (scriptLanguage === 'python' || scriptLanguage === 'jython');
+        const scriptExt = isPython ? '.py' : '.js';
+        
+        const actualLogname = logname || autoscript;
+        logger.info(`[${actualLogname}]成功读取配置文件: ${fileName}`);
+        logger.info(`[${actualLogname}]脚本名称: ${autoscript}`);
+        logger.info(`[${actualLogname}]脚本语言: ${scriptLanguage}`);
+        
+        const dirname = fileName.substring(0, fileName.lastIndexOf('/')) || fileName.substring(0, fileName.lastIndexOf('\\')) || '';
+        const scriptFileName = dirname ? `${dirname}/${autoscript}${scriptExt}` : `${autoscript}${scriptExt}`;
+        
+        const fileContent = readFileContent(scriptFileName);
+        
+        if (!fileContent) {
+            logger.error(`[${actualLogname}]脚本文件读取失败: ${scriptFileName}`);
+            return false;
+        }
+        
+        logger.info(`[${actualLogname}]成功读取脚本文件: ${scriptFileName}`);
+        logger.info(`[${actualLogname}]文件大小: ${fileContent.length} 字节`);
+        
+        await saveScriptHistory({
+            autoscript: autoscript,
+            source: fileContent,
+            version: 'deploy',
+            aliasname: '_script_',
+            hostname: os.hostname()
+        });
+        
+        const ignoreFields = ['BINARYSCRIPTSOURCE', 'AUTOSCRIPTID'];
+        
+        const customFields = {};
+        for (const [key, value] of Object.entries(jsonContent)) {
+            if (ignoreFields.includes(key)) {
+                continue;
+            }
+            if (key === 'SOURCE') {
+                continue;
+            }
+            customFields[key.toLowerCase()] = value;
+        }
+        
+        customFields.autoscript = autoscript;
+        customFields.description = jsonContent.description;
+        customFields.source = fileContent.replace(/\r\n/g, '\n');
+        customFields.scriptlanguage = jsonContent.scriptlanguage;
+        
+        if (jsonContent.active !== undefined) {
+            customFields.active = jsonContent.active === true || jsonContent.active === 1 || jsonContent.active === '1';
+        } else {
+            customFields.active = true;
+        }
+        
+        logger.info(`[${actualLogname}]步骤1: 检查脚本是否存在...`);
+        const checkUrl = `api/os/MXAPIAUTOSCRIPT?lean=1&oslc.select=autoscript&oslc.where=autoscript="${autoscript}"`;
+        
+        let scriptExists = false;
+        let scriptHref = null;
+        
+        try {
+            const checkResult = await request({
+                url: checkUrl,
+                method: 'GET'
+            });
+            
+            if (checkResult && checkResult.member) {
+                const memberCount = checkResult.member.length;
+                if (memberCount === 1) {
+                    scriptExists = true;
+                    scriptHref = checkResult.member[0].href;
+                }
+            }
+        } catch (error) {
+            logger.error(`[${actualLogname}]检查脚本失败:`, error.message);
+        }
+        
+        if (scriptExists) {
+            logger.info(`[${actualLogname}]脚本已存在，将执行更新操作`);
+        } else {
+            logger.info(`[${actualLogname}]脚本不存在，将执行创建操作`);
+        }
+        
+        let deployUrl;
+        let deployMethod = 'POST';
+        
+        var headers={};
+        if (scriptExists && scriptHref) {
+            deployUrl = scriptHref;
+            deployMethod = 'POST';
+            headers =  {
+                'Content-Type': 'application/merge-patch+json',
+                'x-method-override': 'PATCH'
+            };
+            
+        } else {
+            deployUrl = 'api/os/MXAPIAUTOSCRIPT';
+            headers =  {
+                'Content-Type': 'application/json'
+            };
+        }
+        
+        const deployBody = {};
+        
+        for (const key in customFields) {
+            if (customFields.hasOwnProperty(key)) {
+                if (key.toLowerCase() === 'autoscript' || key.toLowerCase() === 'description' || key.toLowerCase() === 'source') {
+                    continue;
+                }
+                if (key.toLowerCase().startsWith('sks:')) {
+                    continue;
+                }
+                if (key.toLowerCase().startsWith('sks:')
+                    || key.toLowerCase() === 'changedate'
+                    || key.toLowerCase() === 'statusdate'
+                ) {
+                    // 跳过 sks: 开头的字段
+                    continue;
+                }
+                
+                if (key.toLowerCase() === 'launchpoints') {
+                    const launchPointsTmp = [];
+                    for (const launchPoint of customFields[key]) {
+                        const launchPointTmp = {};
+                        const ignoreFieldsLaunchpoints = ['eventtype'];
+                        for (const lpKey in launchPoint) {
+                            if (ignoreFieldsLaunchpoints.includes(lpKey.toLowerCase())) {
+                                continue;
+                            }
+                            if (lpKey.startsWith('sks:')) {
+                                continue;
+                            }
+                            if (launchPoint.hasOwnProperty(lpKey)) {
+                                const prefixedKey = `spi:${lpKey.toLowerCase()}`;
+                                launchPointTmp[prefixedKey] = launchPoint[lpKey];
+                            }
+                        }
+                        launchPointsTmp.push(launchPointTmp);
+                    }
+                    deployBody['spi:scriptlaunchpoint'] = launchPointsTmp;
+                    continue;
+                }
+                
+                if (key.toLowerCase() === 'variables') {
+                    const variablesTmp = [];
+                    for (const variable of customFields[key]) {
+                        const variableTmp = {};
+                        for (const lpKey in variable) {
+                            if (variable.hasOwnProperty(lpKey)) {
+                                const prefixedKey = `spi:${lpKey.toLowerCase()}`;
+                                variableTmp[prefixedKey] = variable[lpKey];
+                            }
+                        }
+                        variablesTmp.push(variableTmp);
+                    }
+                    deployBody['spi:autoscriptvars'] = variablesTmp;
+                    continue;
+                }
+                
+                const prefixedKey = `spi:${key.toLowerCase()}`;
+                deployBody[prefixedKey] = customFields[key];
+            }
+        }
+        
+        if (!deployBody['spi:autoscript']) {
+            deployBody['spi:autoscript'] = autoscript;
+        }
+        if (!deployBody['spi:description']) {
+            deployBody['spi:description'] = customFields.description;
+        }
+        if (!deployBody['spi:scriptlanguage']) {
+            deployBody['spi:scriptlanguage'] = customFields.scriptlanguage;
+        }
+        if (deployBody['spi:active'] === undefined) {
+            deployBody['spi:active'] = customFields.active;
+        }
+        if (deployBody['spi:version'] === undefined || deployBody['spi:version'] === '') {
+            deployBody['spi:version'] = '1.0.0';
+        }
+        if (customFields.source) {
+            deployBody['spi:source'] = customFields.source;
+        } else {
+            deployBody['spi:source'] = '';
+        }
+        
+        logger.info(`[${actualLogname}]步骤2: 发送${deployMethod}请求到: ${deployUrl}`);
+        const deployResult = await request({
+            url: deployUrl,
+            method: deployMethod,
+            headers:  {
+                ...headers
+            },
+            data: deployBody
+        });
+        
+        logger.info(`[${actualLogname}]收到响应`);
+        
+        if (deployResult !== null && deployResult !== undefined) {
+            logger.warn(`[${actualLogname}]导入成功`)
+            return true
+        } else {
+            logger.error(`[${actualLogname}]导入失败，响应为空或null`)
+            return false
+        }
+    } catch (error) {
+        logger.error(`请求出错:`, error.message)
+        if (error.response) {
+            // 服务器返回了错误状态码
+        } else if (error.request) {
+            logger.error(`请求已发出但无响应`)
+        } else {
+            logger.error(`错误详情:`, error)
+        }
+        return false
+    }
+}
+
+
 /**
  * 导入Maximo AutoKey配置
  * @param {Object} options - 配置选项
@@ -236,7 +518,7 @@ export async function importMaxAutoKey({fileName, logname}) {
             method: 'post',
             params: {
                 develop: true,
-                _langcode: 'zh',
+                _langcode: getConfig().langcode,
             },
             data: fileContent
         })
@@ -245,6 +527,67 @@ export async function importMaxAutoKey({fileName, 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 importMaxAppInfo({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_IMP_MAXAPPINFO',
+            method: 'post',
+            params: {
+                develop: true,
+                _langcode: getConfig().langcode,
+            },
+            data: fileContent
+        })
+        
+        logger.info(`[${logname}]收到响应`);
+        logger.info(`[${logname}]响应类型:`, typeof response);
+        logger.debug(`[${logname}]响应内容:`, response);
+        
         if (response !== null && response !== undefined) {
             logger.warn(`[${logname}]导入成功`)
             return true

package/nodeutils/requestHttp.js

@@ -1,5 +1,8 @@
 import http from 'http';
 import https from 'https';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 import axios from 'axios';
 import { getConfig } from './config.js';
 import logger from './logger.js';
@@ -24,6 +27,78 @@ function limitLogOutput(data, maxLength = 200) {
   }
 }
 
+function getLogDir() {
+  return path.join(os.homedir(), '.sks', 'nodeutils', 'logs');
+}
+
+function saveRequestLog(config, globalConfig) {
+  try {
+    const logDir = getLogDir();
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const method = config.method?.toUpperCase() || 'GET';
+    let url = `${config.url}`;
+    
+    if (config.params && Object.keys(config.params).length > 0) {
+      const paramsStr = Object.entries(config.params)
+        .map(([key, value]) => `${key}=${value}`)
+        .join('&');
+      url += url.includes('?') ? `&${paramsStr}` : `?${paramsStr}`;
+    }
+
+    let httpContent = `### ${method} ${url}\n`;
+    httpContent += `${method} ${url}\n`;
+
+    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`;
+      }
+    });
+
+    httpContent += '\n';
+    if (config.data) {
+      if (typeof config.data === 'string') {
+        httpContent += config.data;
+      } else {
+        httpContent += JSON.stringify(config.data, null, 2);
+      }
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const fileName = `request-${method}-${timestamp}.http`;
+    const filePath = path.join(logDir, fileName);
+    fs.writeFileSync(filePath, httpContent, 'utf-8');
+
+    logger.error(`[HTTP Log] 请求日志已保存: ${filePath}`);
+  } catch (error) {
+    logger.error('[HTTP Log] 保存请求日志失败:', error.message);
+  }
+}
+
+function saveResponseLog(response) {
+  try {
+    const logDir = getLogDir();
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const method = response.config.method?.toUpperCase() || 'GET';
+    const fileName = `response-${method}-${timestamp}.json`;
+    const filePath = path.join(logDir, fileName);
+
+    fs.writeFileSync(filePath, JSON.stringify(response.data, null, 2), 'utf-8');
+
+    logger.error(`[HTTP Log] 响应日志已保存: ${filePath}`);
+  } catch (error) {
+    logger.error('[HTTP Log] 保存响应日志失败:', error.message);
+  }
+}
+
 // 创建axios实例
 function createService() {
   const config = getConfig();
@@ -62,8 +137,8 @@ function createService() {
     if (!config.params) {
       config.params = {};
     }
-    if (!(config.url.concat('_langcode') || config.params['_langcode'])) {
-      config.params['_langcode'] = 'zh';
+    if (!config.params['_langcode']) {
+      config.params['_langcode'] = globalConfig.langcode || 'zh';
     }
     var url = `${config.method} ${globalConfig.baseUrl}${config.url}`;
     if (config.params && Object.keys(config.params).length > 0) {
@@ -89,6 +164,9 @@ function createService() {
     }
     logger.info(httpContent);
     logger.info('[Request] 请求准备完成，发送请求...');
+    
+    saveRequestLog(config, globalConfig);
+    
     return config;
   }, error => {
     logger.debug(error);
@@ -98,7 +176,9 @@ function createService() {
   // 响应拦截器
   service.interceptors.response.use(res => {
     logger.info('[Response] 收到响应，状态码:', res.status);
-    logger.info('[Response] 响应数据:', res.data);
+    logger.debug('[Response] 响应数据:', res.data);
+    
+    saveResponseLog(res);
 
     // 未设置状态码则默认成功状态
     const code = res.data?.code || res.status || 200;

package/package.json

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