fofstudio
Version:
fofstudio
1,646 lines (1,620 loc) • 61 kB
JavaScript
#!/usr/bin/env node
import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js";
import {StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js";
import fetch from "node-fetch";
import {z} from "zod";
/**
* 自定义单击事件
* @id 选择器
* @fun 点击事件
* */
function baseClick(id, fun) {
document.querySelectorAll(id).forEach(function (v) {
v.addEventListener('click', fun);
});
};
/**
* 自定义双击事件
* @id 选择器
* @fun 点击事件
* */
function baseDblclick(id, fun) {
document.querySelectorAll(id).forEach(function (v) {
v.addEventListener('dblclick', fun);
});
};
/**
* 自定义鼠标按键按下事件
* @id 选择器
* @fun 点击事件
* */
function baseMousedown(id, fun) {
document.querySelectorAll(id).forEach(function (v) {
v.addEventListener('mousedown', fun);
});
};
/**
* 自定义鼠标按键松开事件
* @id 选择器
* @fun 点击事件
* */
function baseMouseup(id, fun) {
document.querySelectorAll(id).forEach(function (v) {
v.addEventListener('mouseup', fun);
});
};
/**
* 自定义鼠标移入事件
* @id 选择器
* @fun 点击事件
* */
function baseMouseenter(id, fun) {
document.querySelectorAll(id).forEach(function (v) {
v.addEventListener('mouseenter', fun);
});
};
/**
* 自定义鼠标移出事件
* @id 选择器
* @fun 点击事件
* */
function baseMouseleave(id, fun) {
document.querySelectorAll(id).forEach(function (v) {
v.addEventListener('mouseleave', fun);
});
};
/**
* 自定义鼠标移动事件
* @id 选择器
* @fun 点击事件
* */
function baseMousemove(id, fun) {
document.querySelectorAll(id).forEach(function (v) {
v.addEventListener('mousemove', fun);
});
};
/**
* Utf8Array转字符串
* @array Utf8Array数据
* */
function Utf8ArrayToStr(array) {
var out, i, len, c;
var char2, char3;
out = "";
len = array.length;
i = 0;
while (i < len) {
c = array[i++];
switch (c >> 4) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
// 0xxxxxxx
out += String.fromCharCode(c);
break;
case 12:
case 13:
// 110x xxxx 10xx xxxx
char2 = array[i++];
out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
break;
case 14:
// 1110 xxxx 10xx xxxx 10xx xxxx
char2 = array[i++];
char3 = array[i++];
out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
break;
}
}
return out;
}
let LetData = {
sqlServer: null,
fofsqlite3: null,
fofmysql: null,
crypto: null,
sharp: null,
email: null,
compress: null,
ftp: null,
fileFOF: null,
DecoderAPI: null,
SendHttp: null,
dnsFOF: null,
EXEAPI: null,
PlatAPI: null,
ReadAPI: null,
ProcessAPI: null,
HttpServer: null,
TcpServer: null,
UdpServer: null,
IPData: null,
BufferClass: null,
DataPackaging: null,
websocket: null,
sms: null,
excel: null,
word: null,
docxObj: null,
wordPath: null,
nodeRsa: null,
ffiNapi: null,
HttpProxy: null,
TxCdn: null,
SerialPortNode: null,
mqttServer: null,
modbus: null,
printWindows: null,
postgres: null,
BaiDuOpencv: null,
Alioss: null
}
let fofletData = LetData;
let electronProcessAPI = {
runExec: (Path, cmdCode, SetProcessYesMsg = undefined, SetProcessNoMsg = undefined, SetProcessEndMsg = undefined, encoding_ = "GBK", env = undefined, ifArr = false) => {
if (LetData.ProcessAPI == null) {
LetData.ProcessAPI = require('./modules/ProcessAPI.js');
}
LetData.ProcessAPI.runExec({ "路径": Path, "code": cmdCode }, SetProcessYesMsg, SetProcessNoMsg, SetProcessEndMsg, encoding_, env, ifArr)
},
runExeckill: () => {
if (LetData.ProcessAPI == null) {
LetData.ProcessAPI = require('./modules/ProcessAPI.js');
}
LetData.ProcessAPI.runExeckill()
},
}
let electronReadAPI = {
readText: () => {
if (LetData.ReadAPI == null) {
LetData.ReadAPI = require('./modules/ReadAPI.js');
}
return LetData.ReadAPI.readText();
},
writeText: (text) => {
if (LetData.ReadAPI == null) {
LetData.ReadAPI = require('./modules/ReadAPI.js');
}
return LetData.ReadAPI.writeText(text);
},
readHTML: () => {
if (LetData.ReadAPI == null) {
LetData.ReadAPI = require('./modules/ReadAPI.js');
}
return LetData.ReadAPI.readHTML();
},
writeHTML: (text) => {
if (LetData.ReadAPI == null) {
LetData.ReadAPI = require('./modules/ReadAPI.js');
}
return LetData.ReadAPI.writeHTML(text);
},
readRTF: () => {
if (LetData.ReadAPI == null) {
LetData.ReadAPI = require('./modules/ReadAPI.js');
}
return LetData.ReadAPI.readRTF();
},
writeRTF: (text) => {
if (LetData.ReadAPI == null) {
LetData.ReadAPI = require('./modules/ReadAPI.js');
}
return LetData.ReadAPI.writeRTF(text);
},
}
let electronPlatAPI = {
getPlatform: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.getPlatform();
},
globalShortcut: (key) => {
//全局快捷键绑定
try {
//只在electron中生效
ipcRenderer.invoke('globalShortcut', key)
} catch (error) {
}
},
Notification: (data) => {
try {
//只在electron中生效
ipcRenderer.invoke('Notification', data)
} catch (error) {
}
},
openAtLogin: (true_) => {
try {
//只在electron中生效
ipcRenderer.invoke('openAtLogin', true_)
} catch (error) {
}
},
powerSaveBlocker: () => {
try {
//只在electron中生效
ipcRenderer.invoke('powerSaveBlocker')
} catch (error) {
}
},
processArgv: () => {
return process.argv;
},
getCursorScreenPoint: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.getCursorScreenPoint()
},
dipToScreenPoint: (data) => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.dipToScreenPoint(data)
},
networkInterfaces: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.networkInterfaces()
},
getLocalIP: () => {
if (LetData.IPData == null) {
LetData.IPData = require('./modules/IP.js');
}
return LetData.IPData.getLocalIP()
},
cpus: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.cpus()
},
tmpDir: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.tmpDir()
},
arch: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.arch()
},
totalmem: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.totalmem()
},
freemem: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.freemem()
},
OStype: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.OStype()
},
hostname: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.hostname()
},
release: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.release()
},
uptime: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.uptime()
},
loadavg: () => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
return LetData.PlatAPI.loadavg()
},
showItemInFolder: (fullPath) => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
LetData.PlatAPI.showItemInFolder(fullPath)
},
openPath: (fullPath) => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
LetData.PlatAPI.openPath(fullPath)
},
openExternal: (url) => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
LetData.PlatAPI.openExternal(url)
},
trashItem: (fullPath) => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
LetData.PlatAPI.trashItem(fullPath)
},
openItem: (fullPath) => {
if (LetData.PlatAPI == null) {
LetData.PlatAPI = require('./modules/PlatAPI.js');
}
LetData.PlatAPI.openItem(fullPath)
},
}
let electronEXEAPI = {
OpenEXE: (path) => {
if (LetData.EXEAPI == null) {
LetData.EXEAPI = require('./modules/EXEAPI.js');
}
return LetData.EXEAPI.OpenEXE(path)
},
KillEXE: (pid) => {
if (LetData.EXEAPI == null) {
LetData.EXEAPI = require('./modules/EXEAPI.js');
}
return LetData.EXEAPI.KillEXE(pid)
},
DoesTheProcessExist: (query, cb, encoding = "GBK") => {
if (LetData.EXEAPI == null) {
LetData.EXEAPI = require('./modules/EXEAPI.js');
}
return LetData.EXEAPI.DoesTheProcessExist(query, cb, encoding)
},
}
let electronDnsAPI = {
lookup: (url, funStr = undefined) => {
if (LetData.dnsFOF == null) {
LetData.dnsFOF = require('./modules/dns.js');
}
LetData.dnsFOF.lookup(url, funStr)
},
lookupService: (address, family, funStr = undefined) => {
if (LetData.dnsFOF == null) {
LetData.dnsFOF = require('./modules/dns.js');
}
LetData.dnsFOF.lookupService(address, family, funStr)
},
resolve4: (url, funStr = undefined) => {
if (LetData.dnsFOF == null) {
LetData.dnsFOF = require('./modules/dns.js');
}
LetData.dnsFOF.resolve4(url, funStr)
},
resolve6: (url, funStr) => {
if (LetData.dnsFOF == null) {
LetData.dnsFOF = require('./modules/dns.js');
}
LetData.dnsFOF.resolve6(url, funStr)
},
reverse: (ip, funStr) => {
if (LetData.dnsFOF == null) {
LetData.dnsFOF = require('./modules/dns.js');
}
LetData.dnsFOF.reverse(ip, funStr)
},
}
let electronFileAPI = {
getAppPath: () => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.getAppPath();
},
getDesktop: () => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.getDesktop();
},
getPathAll: () => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.getPathAll();
},
listFile: (path, funEv = undefined) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
LetData.fileFOF.listFile(path, funEv);
},
watch: (path, funEv = undefined) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
LetData.fileFOF.watch(path, funEv);
},
getExe: () => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.getExe();
},
existsSync: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.existsSync(path);
},
writeFileSync: (path, data) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.writeFileSync({ "路径": path, "数据": data });
},
writeFileBase64Sync: (path, data) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.writeFileBase64Sync({ "路径": path, "数据": data });
},
writeFileHexSync: (path, data) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.writeFileHexSync({ "路径": path, "数据": data });
},
readFileSync: (path, unicode = "utf8") => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.readFileSync({ "路径": path, "编码": unicode });
},
readFileBase64Sync: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.readFileBase64Sync({ "路径": path });
},
readFileHexSync: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.readFileHexSync({ "路径": path });
},
mkdirSync: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.mkdirSync(path);
},
cp: (path, path2, funEv = undefined) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.cp(path, path2, funEv);
},
renameSync: (path, newPath) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.renameSync({ "路径": path, "路径2": newPath });
},
unlink: (path, funEv = undefined) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.unlink(path, funEv);
},
appendFile: (path, data) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.appendFile({ "路径": path, "数据": data });
},
basename: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.basename(path);
},
dirname: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.dirname(path);
},
extname: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.extname(path);
},
isAbsolute: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.isAbsolute(path);
},
normalize: (path) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.normalize(path);
},
FileMsg: (path, EVFun) => {
if (LetData.fileFOF == null) {
LetData.fileFOF = require('./modules/File.js');
}
return LetData.fileFOF.FileMsg(path, EVFun);
},
}
let electronDecoderAPI = {
TextDecoder: (Decoder, Code, hexTrue = false, hexCode = "hex") => {
if (LetData.DecoderAPI == null) {
LetData.DecoderAPI = require('./modules/DecoderAPI.js');
}
return LetData.DecoderAPI.TextDecoder(Decoder, Code, hexTrue, hexCode);
},
TextDecoderBase64: (Decoder, Code) => {
if (LetData.DecoderAPI == null) {
LetData.DecoderAPI = require('./modules/DecoderAPI.js');
}
return LetData.DecoderAPI.TextDecoderBase64(Decoder, Code);
},
TextToBase64: (Code) => {
if (LetData.DecoderAPI == null) {
LetData.DecoderAPI = require('./modules/DecoderAPI.js');
}
return LetData.DecoderAPI.TextToBase64(Code);
},
Base64ToText: (Code) => {
if (LetData.DecoderAPI == null) {
LetData.DecoderAPI = require('./modules/DecoderAPI.js');
}
return LetData.DecoderAPI.Base64ToText(Code);
},
TextTo16: (Code) => {
if (LetData.DecoderAPI == null) {
LetData.DecoderAPI = require('./modules/DecoderAPI.js');
}
return LetData.DecoderAPI.TextTo16(Code);
},
HexToText: (Code) => {
if (LetData.DecoderAPI == null) {
LetData.DecoderAPI = require('./modules/DecoderAPI.js');
}
return LetData.DecoderAPI.HexToText(Code);
},
}
let electronHTTPAPI = {
httpSend: (url, RetFun = undefined, method_ = "GET", POSTDATA = "", headers_ = {}) => {
if (LetData.SendHttp == null) {
LetData.SendHttp = require('./modules/SendHttp.js');
}
LetData.SendHttp.httpSend(url, RetFun, method_, POSTDATA, headers_);
},
httpsSend: (url, RetFun = undefined, method_ = "GET", POSTDATA = "", headers_ = {}) => {
if (LetData.SendHttp == null) {
LetData.SendHttp = require('./modules/SendHttp.js');
}
LetData.SendHttp.httpsSend(url, RetFun, method_, POSTDATA, headers_);
},
}
let electronSqlServer = {
sendsqlserver: (funStr, host, user, password, database, port = 1433, max = 20, if2000 = false, obj = undefined) => {
if (LetData.sqlServer == null) {
LetData.sqlServer = require('./modules/sqlServer.js');
}
return LetData.sqlServer.sendsqlserver(funStr, host, user, password, database, port, max, if2000, obj);
},
exec: (funStr, sqltXet, values, poolID = 0) => {
if (LetData.sqlServer == null) {
LetData.sqlServer = require('./modules/sqlServer.js');
}
LetData.sqlServer.exec(sqltXet, values, poolID, funStr)
},
exec2: async (sqltXet, values, poolID = 0) => {
if (LetData.sqlServer == null) {
LetData.sqlServer = require('./modules/sqlServer.js');
}
let RetExec = await LetData.sqlServer.exec(sqltXet, values, poolID, undefined)
return RetExec;
},
execTransaction: (funStr, sqltXet, poolID = 0, TransactionType = {}) => {
if (LetData.sqlServer == null) {
LetData.sqlServer = require('./modules/sqlServer.js');
}
LetData.sqlServer.execTransaction(sqltXet, poolID, funStr, TransactionType);
},
execTransaction2: async (sqltXet, poolID = 0, TransactionType = {}) => {
if (LetData.sqlServer == null) {
LetData.sqlServer = require('./modules/sqlServer.js');
}
let RetData = {};
await LetData.sqlServer.execTransaction(sqltXet, poolID, undefined, TransactionType)
.then(res => {
RetData = res;
})
.catch(err => RetData = { "状态": "失败", "数据": err });
return RetData;
},
endPool: (poolID = 0) => {
if (LetData.sqlServer == null) {
LetData.sqlServer = require('./modules/sqlServer.js');
}
LetData.sqlServer.endPool(poolID);
},
}
let electronMysql = {
sendmysql: (funStr, host, user, password, database, port = 3306, connectionLimit = 20, Obj = {}) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
return LetData.fofmysql.sendmysql(funStr, host, user, password, database, port, connectionLimit, Obj)
},
query: (funStr, sqltXet, params = [], poolID = 0) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
LetData.fofmysql.query(sqltXet, params, poolID, funStr)
},
query2: async (sqltXet, params = [], poolID = 0) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
let RetData = {};
await LetData.fofmysql.query(sqltXet, params, poolID).then(res => {
RetData = { "状态": "成功", "数据": res }
}).catch(err => RetData = { "状态": "失败", "数据": err })
try {
if (RetData["数据"] == false) {
if (Array.isArray(RetData["数据"]) == false) {
RetData["数据"] = [];
RetData["状态"] == "失败"
}
}
} catch (error) {
}
return RetData;
},
exec: (funStr, sqltXet, values = [], poolID = 0) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
LetData.fofmysql.exec(sqltXet, values, poolID, funStr)
},
exec2: async (sqltXet, values = [], poolID = 0) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
let RetData = {};
await LetData.fofmysql.exec(sqltXet, values, poolID).then(res => {
RetData = { "状态": "成功", "数据": res && res.affectedRows > 0, "数据2": res }
}).catch(err => RetData = { "状态": "失败", "数据": err, "数据2": {} });
return RetData;
},
execTransaction: (funStr, sqlArr, poolID = 0, TransactionType = {}) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
if (sqlArr.length <= 0) {
LetData.fofmysql.execTransaction(sqlArr, poolID, funStr, TransactionType);
} else {
LetData.fofmysql.execTransaction(sqlArr, poolID)
.then(res => funStr({ "状态": "成功", "事务状态": "成功", "数据": res }))
.catch(err => funStr({ "状态": "失败", "事务状态": "无状态", "数据": err }));
}
},
execTransaction2: async (sqlArr, poolID = 0, TransactionType = {}) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
let RetData = {};
if (sqlArr.length <= 0) {
RetData = await LetData.fofmysql.execTransaction(sqlArr, poolID, undefined, TransactionType);
return RetData;
} else {
await LetData.fofmysql.execTransaction(sqlArr, poolID)
.then(res => RetData = { "状态": "成功", "事务状态": "成功", "数据": res })
.catch(err => RetData = { "状态": "失败", "事务状态": "无状态", "数据": err });
return RetData;
}
},
endPool: (poolID = 0) => {
if (LetData.fofmysql == null) {
LetData.fofmysql = require('./modules/mysql.js');
}
LetData.fofmysql.endPool(poolID);
},
}
let electronCrypto = {
md5: (data) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.md5(data);
},
sha1: (data) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.sha1(data);
},
md5hmac: (data, password) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.md5hmac(data, password);
},
sha256: (data) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.sha256(data);
},
sha256hmac: (data, password) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.sha256hmac(data, password);
},
shaSet: (type, data) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.shaSet(type, data);
},
shaSethmac: (type, data, password) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.shaSethmac(type, data, password);
},
encryptBase64: (data) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.encryptBase64(data);
},
decryptBase64: (data) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.decryptBase64(data);
},
encryptDes: (str, key, iv = null, destype = 'des-ecb') => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.encryptDes(str, key, iv, destype);
},
decryptDes: (str, key, iv = null, destype = 'des-ecb') => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.decryptDes(str, key, iv, destype);
},
encryptAes: (str, key, iv = null, destype = 'aes-128-ecb') => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.encryptAes(str, key, iv, destype);
},
decryptAes: (str, key, iv = null, destype = 'aes-128-ecb') => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.decryptAes(str, key, iv, destype);
},
generateRSAKey: (size = 1024) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.generateRSAKey(size);
},
encryptRSAByPrivateKey: (str, privateKey) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.encryptRSAByPrivateKey(str, privateKey);
},
decryptRSAByPublicKey: (str, privateKey) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.decryptRSAByPublicKey(str, privateKey);
},
encryptRSAByPublicKey: (str, privateKey) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.encryptRSAByPublicKey(str, privateKey);
},
decryptRSAByPrivateKey: (str, privateKey) => {
if (LetData.crypto == null) {
LetData.crypto = require('./modules/crypto.js');
}
return LetData.crypto.decryptRSAByPrivateKey(str, privateKey);
},
}
let electronSharp = {
metadata: (img, funStr) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.metadata(img).then(res => funStr({ "宽度": res.width, "高度": res.height, "格式": res.format }))
},
resize: (img, options, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.resize(img, options, savePath, funStr);
},
border: (img, options, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.border(img, options, savePath, funStr);
},
crop: (img, options, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.crop(img, options, savePath, funStr);
},
format: (img, type, quality = 80, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.format(img, type, quality, savePath, funStr);
},
rotate: (img, angle, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.rotate(img, angle, savePath, funStr);
},
rotateBlur: (img, sigma, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.rotateBlur(img, sigma, savePath, funStr);
},
greyscale: (img, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.greyscale(img, savePath, funStr);
},
watermark: (img, text, options = {}, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.watermark(img, text, options, savePath, funStr);
},
watermarkFun: (img, text, options = {}, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.watermarkFun(img, text, options, savePath, funStr);
},
tint: (img, rgb, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.tint(img, rgb, savePath, funStr);
},
compose: (img, options, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.compose(img, options, savePath, funStr);
},
sharpen: (img, options, savePath, funStr = undefined) => {
if (LetData.sharp == null) {
LetData.sharp = require('./modules/sharp.js');
}
LetData.sharp.sharpen(img, options, savePath, funStr);
},
}
let electronEmailAPI = {
sendMail: (host, port, name, user, pass, sendto, title, contents, attachments_ = [], funStr = undefined) => {
if (LetData.email == null) {
LetData.email = require('./modules/email.js');
}
LetData.email.sendMail(host, port, name, user, pass, sendto, title, contents, attachments_, funStr);
},
}
let electronCompressAPI = {
compressDir: (dirPath, output, format, funStr = undefined) => {
if (LetData.compress == null) {
LetData.compress = require('./modules/compress.js');
}
LetData.compress.compressDir(dirPath, output, format, funStr);
},
compressFile: (filePath, output, format, funStr = undefined) => {
if (LetData.compress == null) {
LetData.compress = require('./modules/compress.js');
}
LetData.compress.compressFile(filePath, output, format, funStr);
},
compressFileBatch: (filePathArr, output, format, funStr = undefined) => {
if (LetData.compress == null) {
LetData.compress = require('./modules/compress.js');
}
LetData.compress.compressFileBatch(filePathArr, output, format, funStr);
},
unCompress: (filePath, output, funStr = undefined) => {
if (LetData.compress == null) {
LetData.compress = require('./modules/compress.js');
}
LetData.compress.unCompress(filePath, output, funStr);
},
}
let electronFtpAPI = {
config: (host_, port_, user_, password_) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.config(host_, port_ + "", user_, password_);
},
list: (funStr = undefined, path = "") => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.list(funStr, path);
},
download: (targetPath, savePath, funStr = undefined) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.download(targetPath, savePath, funStr);
},
upload: (filePath, savePath, funStr = undefined) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.upload(savePath, filePath, funStr);
},
delete: (filePath, funStr = undefined) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.delete(filePath, funStr);
},
rename: (oldPath, newPath, funStr = undefined) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.rename(oldPath, newPath, funStr);
},
mkDir: (dirPath, funStr = undefined) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.mkDir(dirPath, funStr);
},
rmDir: (dirPath, funStr = undefined) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.rmDir(dirPath, funStr);
},
size: (filePath, funStr = undefined) => {
if (LetData.ftp == null) {
LetData.ftp = require('./modules/ftp.js');
}
LetData.ftp.size(filePath, funStr);
},
}
let electronHttpServerAPI = {
initServer: (Data, MsgFun = undefined, funGet = undefined, funPost = undefined, funPut = undefined) => {
if (LetData.HttpServer == null) {
LetData.HttpServer = require('./modules/HttpServer.js');
}
return LetData.HttpServer.initServer(Data, MsgFun, funGet, funPost, funPut);
},
getTypeMime: (extname) => {
if (LetData.HttpServer == null) {
LetData.HttpServer = require('./modules/HttpServer.js');
}
return LetData.HttpServer.getTypeMime(extname);
},
serverClose: (IntID) => {
if (LetData.HttpServer == null) {
LetData.HttpServer = require('./modules/HttpServer.js');
}
LetData.HttpServer.serverClose(IntID);
},
}
let electronTcpServerAPI = {
NewServer: (ServerData, MsgFun = undefined) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.NewServer(ServerData, MsgFun);
},
InsertIPBlacklist: (ip) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.InsertIPBlacklist(ip);
},
ServerClose: (server) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.ServerClose(server);
},
send: (ServerIDInt, id, data) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
LetData.TcpServer.send(ServerIDInt, id, data);
},
Disconnect: (ServerIDInt, id) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
LetData.TcpServer.Disconnect(ServerIDInt, id);
},
socketList: (ServerIDInt) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.socketList(ServerIDInt);
}
}
let electronTcpSocketAPI = {
NewSocket: (ServerData, MsgFun = undefined) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.NewSocket(ServerData, MsgFun);
},
SocketWrite: (IntServer, Data) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.SocketWrite(IntServer, Data);
},
SocketReadyState: (IntServer) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.SocketReadyState(IntServer);
},
SocketDestroy: (IntServer) => {
if (LetData.TcpServer == null) {
LetData.TcpServer = require('./modules/FOFTcp.js');
}
return LetData.TcpServer.SocketDestroy(IntServer);
},
}
let electronUdpServerAPI = {
NewServer: (port = 22333, MsgFun = undefined) => {
if (LetData.UdpServer == null) {
LetData.UdpServer = require('./modules/FOFUDP.js');
}
return LetData.UdpServer.NewServer(port, MsgFun);
},
ServerClose: (IntServer) => {
if (LetData.UdpServer == null) {
LetData.UdpServer = require('./modules/FOFUDP.js');
}
return LetData.UdpServer.ServerClose(IntServer);
},
ServerSend: (IntServer, data, address, port) => {
if (LetData.UdpServer == null) {
LetData.UdpServer = require('./modules/FOFUDP.js');
}
return LetData.UdpServer.ServerSend(IntServer, data, address, port);
}
}
let electronUdpClientAPI = {
NewClient: (MsgFun = undefined) => {
if (LetData.UdpServer == null) {
LetData.UdpServer = require('./modules/FOFUDP.js');
}
return LetData.UdpServer.NewClient(MsgFun);
},
ClientClose: (IntServer) => {
if (LetData.UdpServer == null) {
LetData.UdpServer = require('./modules/FOFUDP.js');
}
return LetData.UdpServer.ClientClose(IntServer);
},
ClientSend: (IntServer, message, address, port) => {
if (LetData.UdpServer == null) {
LetData.UdpServer = require('./modules/FOFUDP.js');
}
return LetData.UdpServer.ClientSend(IntServer, message, address, port);
}
}
let BufferClass = {
BufferClassToArrar: (data) => {
if (LetData.BufferClass == null) {
LetData.BufferClass = require('./modules/BufferClass.js');
}
return LetData.BufferClass.BufferClassToArrar(data);
},
ArrarToBufferClass: (data) => {
if (LetData.BufferClass == null) {
LetData.BufferClass = require('./modules/BufferClass.js');
}
return LetData.BufferClass.ArrarToBufferClass(data);
}
}
let DataPackaging = {
NewID: (ID, dataHead, dataEnd) => {
if (LetData.DataPackaging == null) {
LetData.DataPackaging = require('./modules/DataPackaging.js');
}
return LetData.DataPackaging.NewID(ID, dataHead, dataEnd);
},
InsertData: (ID, Data) => {
if (LetData.DataPackaging == null) {
LetData.DataPackaging = require('./modules/DataPackaging.js');
}
return LetData.DataPackaging.InsertData(ID, Data);
},
SelectData: (ID) => {
if (LetData.DataPackaging == null) {
LetData.DataPackaging = require('./modules/DataPackaging.js');
}
return LetData.DataPackaging.SelectData(ID);
},
IFDataLength: (ID) => {
if (LetData.DataPackaging == null) {
LetData.DataPackaging = require('./modules/DataPackaging.js');
}
return LetData.DataPackaging.IFDataLength(ID);
},
DeleteData: (ID) => {
if (LetData.DataPackaging == null) {
LetData.DataPackaging = require('./modules/DataPackaging.js');
}
return LetData.DataPackaging.DeleteData(ID);
}
}
let websocketServer = {
initWebSocketServer: (port_ = 8080, fun = undefined) => {
if (LetData.websocket == null) {
LetData.websocket = require('./modules/WebSocKet.js');
}
return LetData.websocket.initWebSocketServer(port_, fun);
},
send: (ServerIDInt, id, data) => {
if (LetData.websocket == null) {
LetData.websocket = require('./modules/WebSocKet.js');
}
LetData.websocket.send(ServerIDInt, id, data);
},
Disconnect: (ServerIDInt, id) => {
if (LetData.websocket == null) {
LetData.websocket = require('./modules/WebSocKet.js');
}
LetData.websocket.Disconnect(ServerIDInt, id);
},
socketList: (ServerIDInt) => {
if (LetData.websocket == null) {
LetData.websocket = require('./modules/WebSocKet.js');
}
return LetData.websocket.socketList(ServerIDInt);
}
}
let electronSqlite3 = {
SetDatabase: (dbpath, password) => {
if (LetData.fofsqlite3 == null) {
LetData.fofsqlite3 = require('./modules/sqlite3.js');
}
return LetData.fofsqlite3.SetDatabase(dbpath, password)
},
query: (funStr, sqltXet, params, DBID = null) => {
if (LetData.fofsqlite3 == null) {
LetData.fofsqlite3 = require('./modules/sqlite3.js');
}
LetData.fofsqlite3.query(sqltXet, params, DBID).then(res => {
funStr({ "状态": "成功", "数据": res })
}).catch(err => funStr({ "状态": "失败", "数据": err }))
},
query2: async (sqltXet, params, DBID = null) => {
if (LetData.fofsqlite3 == null) {
LetData.fofsqlite3 = require('./modules/sqlite3.js');
}
let RetData = {};
await LetData.fofsqlite3.query(sqltXet, params, DBID).then(res => {
RetData = { "状态": "成功", "数据": res }
}).catch(err => RetData = { "状态": "失败", "数据": err })
return RetData;
},
exec: (funStr, sqltXet, values = [], DBID = null) => {
if (LetData.fofsqlite3 == null) {
LetData.fofsqlite3 = require('./modules/sqlite3.js');
}
LetData.fofsqlite3.exec(sqltXet, values, DBID).then(res => res ? funStr({ "状态": "成功", "数据": res }) : funStr({ "状态": "失败", "数据": res })).catch(err => funStr({ "状态": "失败", "数据": err }));
},
exec2: async (sqltXet, values = [], DBID = null) => {
if (LetData.fofsqlite3 == null) {
LetData.fofsqlite3 = require('./modules/sqlite3.js');
}
let RetData = {};
await LetData.fofsqlite3.exec(sqltXet, values, DBID).then(res => res ? RetData = { "状态": "成功", "数据": res } : RetData = { "状态": "失败", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
return RetData;
},
execTransaction: (funStr, sqlArr) => {
if (LetData.fofsqlite3 == null) {
LetData.fofsqlite3 = require('./modules/sqlite3.js');
}
LetData.fofsqlite3.execTransaction(sqlArr)
.then(res => res ? funStr({ "状态": "成功", "事务状态": "成功", "数据": res }) : funStr({ "状态": "失败", "事务状态": "失败并回滚", "数据": res }))
.catch(err => funStr({ "状态": "失败", "事务状态": "无状态", "数据": err }));
},
execTransaction2: async (sqlArr) => {
if (LetData.fofsqlite3 == null) {
LetData.fofsqlite3 = require('./modules/sqlite3.js');
}
let RetData = {};
await LetData.fofsqlite3.execTransaction(sqlArr)
.then(res => res ? RetData = { "状态": "成功", "事务状态": "成功", "数据": res } : RetData = { "状态": "失败", "事务状态": "失败并回滚", "数据": res })
.catch(err => RetData = { "状态": "失败", "事务状态": "无状态", "数据": err });
return RetData;
},
}
let electronSms = {
generateCode: (bit = 6, onlyNumber = true) => {
if (LetData.sms == null) {
LetData.sms = require('./modules/sms.js');
}
return LetData.sms.generateCode(bit, onlyNumber)
},
sendAliSMS: (fun = undefined, config = {}, phone, params = {}) => {
if (LetData.sms == null) {
LetData.sms = require('./modules/sms.js');
}
LetData.sms.sendAliSMS(config, phone, params).then(res => res ? fun({ "状态": "成功" }) : fun({ "状态": "失败", "数据": res })).catch(err => fun({ "状态": "失败", "数据": err }));
},
sendTencentSMS: (fun = undefined, config = {}, phone, params = []) => {
if (LetData.sms == null) {
LetData.sms = require('./modules/sms.js');
}
LetData.sms.sendTencentSMS(config, phone, params).then(res => res ? fun({ "状态": "成功" }) : fun({ "状态": "失败", "数据": res })).catch(err => fun({ "状态": "失败", "数据": err }));
},
sendAliSMS2: async (config = {}, phone, params = {}) => {
if (LetData.sms == null) {
LetData.sms = require('./modules/sms.js');
}
let RetData = {};
await LetData.sms.sendAliSMS(config, phone, params).then(res => RetData = { "状态": "成功", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
return RetData;
},
sendTencentSMS2: async (config = {}, phone, params = []) => {
if (LetData.sms == null) {
LetData.sms = require('./modules/sms.js');
}
let RetData = {};
await LetData.sms.sendTencentSMS(config, phone, params).then(res => RetData = { "状态": "成功", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
return RetData;
}
}
let electronExcel = {
readFileSheet: (filePath, sheetName) => {
if (LetData.excel == null) {
LetData.excel = require('./modules/excel.js');
}
return LetData.excel.readFileSheet(filePath, sheetName)
},
readFileToJson: (filePath, sheetName) => {
if (LetData.excel == null) {
LetData.excel = require('./modules/excel.js');
}
return LetData.excel.readFileToJson(filePath, sheetName)
},
readFileToHtml: (filePath, sheetName) => {
if (LetData.excel == null) {
LetData.excel = require('./modules/excel.js');
}
return LetData.excel.readFileToHtml(filePath, sheetName)
},
readFileToCsv: (filePath, sheetName) => {
if (LetData.excel == null) {
LetData.excel = require('./modules/excel.js');
}
return LetData.excel.readFileToCsv(filePath, sheetName)
},
createFileFrom: (data, savePath = "", sheetName = 'sheet1') => {
if (LetData.excel == null) {
LetData.excel = require('./modules/excel.js');
}
LetData.excel.createFileFrom(data, savePath, sheetName)
},
createFileFromArray: (data, savePath = "", sheetName = 'sheet1') => {
if (LetData.excel == null) {
LetData.excel = require('./modules/excel.js');
}
LetData.excel.createFileFromArray(data, savePath, sheetName)
},
createFileFromJsonArray: (data, savePath = "", sheetName = 'sheet1') => {
if (LetData.excel == null) {
LetData.excel = require('./modules/excel.js');
}
LetData.excel.createFileFromJsonArray(data, savePath, sheetName)
},
}
let electronWrod = {
insertWordText: (content, paragraphStyle = 0, textStyle) => {
LetData.docxObj.insertWordText(content, paragraphStyle, textStyle)
},
insertWordImage: (imagePath, paragraphStyle = 0, imageStyle) => {
LetData.docxObj.insertWordImage(imagePath, paragraphStyle, imageStyle)
},
insertWordTable: (tableArray, tableStyle) => {
LetData.docxObj.insertWordTable(tableArray, tableStyle)
},
insertWordHeader: (content, paragraphStyle, textStyle) => {
LetData.docxObj.insertWordHeader(content, paragraphStyle, textStyle)
},
insertWordFooter: (content, paragraphStyle, textStyle) => {
LetData.docxObj.insertWordFooter(content, paragraphStyle, textStyle)
},
insertHorizontalLine: () => {
LetData.docxObj.insertHorizontalLine()
},
insertSoftEnter: () => {
LetData.docxObj.insertSoftEnter()
},
insertPageBreak: () => {
LetData.docxObj.insertPageBreak()
},
insertListItem: (content, style, dots = true, level) => {
LetData.docxObj.insertListItem(content, style, dots, level)
},
output: (fun = undefined) => {
LetData.docxObj.output(LetData.wordPath, fun)
},
NewWord: (filePath) => {
if (LetData.word == null) {
LetData.word = require('./modules/word.js');
}
LetData.docxObj = LetData.word.createWord({
creator: 'MrJiang',
description: 'This is Through NodeJS Operate Microsoft Office Word Library Demo.',
title: 'Microsoft Office Word Demo For NodeJS',
subject: 'Microsoft Office Word Library',
})
LetData.wordPath = filePath;
},
}
let FOFnodeRsa = {
RsaSign: (Str, RsaKey, KeyLengTh = 1024, signingScheme = "sha256", userPrivateKey = 'pkcs8-private') => {
if (LetData.nodeRsa == null) {
LetData.nodeRsa = require('./modules/NodeRsa.js');
}
return LetData.nodeRsa.RsaSign(Str, RsaKey, KeyLengTh, signingScheme, userPrivateKey)
}
}
let FOFffiNapi = {
insertCode: (file, code) => {
if (LetData.ffiNapi == null) {
LetData.ffiNapi = require('./modules/ffiNapi.js');
}
return LetData.ffiNapi.insertCode(file, code)
},
GetCallback: (name, int_ = 0) => {
if (LetData.ffiNapi == null) {
LetData.ffiNapi = require('./modules/ffiNapi.js');
}
return LetData.ffiNapi.GetCallback(name, int_)
},
RetCodeList: (name, int_ = 0) => {
if (LetData.ffiNapi == null) {
LetData.ffiNapi = require('./modules/ffiNapi.js');
}
return LetData.ffiNapi.RetCodeList(name, int_)
},
struct: (name, struct_) => {
if (LetData.ffiNapi == null) {
LetData.ffiNapi = require('./modules/ffiNapi.js');
}
return LetData.ffiNapi.struct(name, struct_)
},
}
let electronHttpProxy = {
httpProxyServer: (serverPort = 1234, pathname = [], setHeader = [], serverFun, pathnameFun) => {
if (LetData.HttpProxy == null) {
LetData.HttpProxy = require('./modules/HttpProxy.js');
}
return LetData.HttpProxy.httpProxyServer(serverPort, pathname, setHeader, serverFun, pathnameFun)
}
}
let electronTxCdn = {
initialization: (secretId, secretKey) => {
if (LetData.TxCdn == null) {
LetData.TxCdn = require('./modules/TxCdn.js');
}
return LetData.TxCdn.initialization(secretId, secretKey)
},
Deactivate: (Domain, funEv) => {
if (LetData.TxCdn == null) {
LetData.TxCdn = require('./modules/TxCdn.js');
}
return LetData.TxCdn.Deactivate(Domain, funEv)
},
Enable: (Domain, funEv) => {
if (LetData.TxCdn == null) {
LetData.TxCdn = require('./modules/TxCdn.js');
}
return LetData.TxCdn.Enable(Domain, funEv)
}
}
let electronSerialPortNode = {
SerialPort: (Fun, path, baudRate, Data_ = {}) => {
if (LetData.SerialPortNode == null) {
LetData.SerialPortNode = require('./modules/SerialPortNode.js');
}
return LetData.SerialPortNode.SerialPort(Fun, path, baudRate, Data_)
},
GetSerialPort: (Fun = undefined) => {
if (LetData.SerialPortNode == null) {
LetData.SerialPortNode = require('./modules/SerialPortNode.js');
}
return LetData.SerialPortNode.GetSerialPort(Fun)
},
SetWrite: (Data, DataType = 1, Point = 0, Fun = undefined) => {
if (LetData.SerialPortNode == null) {
LetData.SerialPortNode = require('./modules/SerialPortNode.js');
}
return LetData.SerialPortNode.SetWrite(Data, DataType, Point, Fun)
}
}
let electronMqttServer = {
NewMqttServer: (port_ = 1883, http_port = 8082, UserPass = [], ready = undefined, clientConnected = undefined, published = undefined, clientDisconnected = undefined, MqttErr = undefined, clientError = undefined) => {
if (LetData.mqttServer == null) {
LetData.mqttServer = require('./modules/mqttServer.js');
}
return LetData.mqttServer.NewMqttServer(port_, http_port, UserPass, ready, clientConnected, published, clientDisconnected, MqttErr, clientError)
},
publish: (ServerID = 0, topic_, Msg, qos_ = 0, retain_ = false, msgFun = undefined) => {
if (LetData.mqttServer == null) {
LetData.mqttServer = require('./modules/mqttServer.js');
}
return LetData.mqttServer.publish(ServerID, topic_, Msg, qos_, retain_, msgFun)
},
close: (ServerID = 0) => {
if (LetData.mqttServer == null) {
LetData.mqttServer = require('./modules/mqttServer.js');
}
return LetData.mqttServer.close(ServerID)
},
}
let modbusClient = {
NewClientTcp: (link = "127.0.0.1", port_ = 8502, MsgFun = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.NewClientTcp(link, port_, MsgFun)
},
NewClientUdp: (link = "127.0.0.1", port_ = 8502, MsgFun = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.NewClientUdp(link, port_, MsgFun)
},
NewClientBuffered: (SerialPortPath = "/dev/ttyUSB0", options = { baudRate: 9600 }, MsgFun = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.NewClientBuffered(SerialPortPath, options, MsgFun)
},
setID: (clientID, ID) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.setID(clientID, ID)
},
getID: (clientID) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.getID(clientID)
},
setTimeout: (clientID, Time) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.setTimeout(clientID, Time)
},
getTimeout: (clientID) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.getTimeout(clientID)
},
isOpen: (clientID) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.isOpen(clientID)
},
writeRegisters: (clientID, address, arg = [0, 0xffff], Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.writeRegisters(clientID, address, arg, Fun_)
},
writeCoil: (clientID, address, arg = 1, Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.writeCoil(clientID, address, arg, Fun_)
},
writeCoils: (clientID, address, arg = [], Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.writeCoils(clientID, address, arg, Fun_)
},
readCoils: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.readCoils(clientID, beginaddress, endaddress, Fun_)
},
readHoldingRegisters: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.readHoldingRegisters(clientID, beginaddress, endaddress, Fun_)
},
readInputRegisters: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.readInputRegisters(clientID, beginaddress, endaddress, Fun_)
},
readRegistersEnron: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
LetData.modbus.readRegistersEnron(clientID, beginaddress, endaddress, Fun_)
},
}
let modbusTCPServer = {
NewServer: (host_ = "0.0.0.0", port_ = 8502, debug_ = true, unitID_ = 1, Fun_ = undefined, setRegister_ = undefined, getHoldingRegister_ = undefined, getInputRegister_ = undefined, getCoil_ = undefined, setCoil_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.NewServer(host_, port_, debug_, unitID_, Fun_, setRegister_, getHoldingRegister_, getInputRegister_, getCoil_, setCoil_)
},
close: (ServerID, Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.close(ServerID, Fun_)
},
getConnections: (ServerID, Fun_ = undefined) => {
if (LetData.modbus == null) {
LetData.modbus = require('./modules/modbus.js');
}
return LetData.modbus.getConnections(ServerID, Fun_)
},
}
let electronPostgres = {
sendPostgres: (funStr, host, user, password, database, port = 3306, connectionLimit = 20) => {
if (LetData.postgres == null) {
LetData.postgres = require('./modules/postgres.js');
}
return LetData.postgres.sendPostgres(funStr, host, user, password, database, port, connectionLimit)
},
exec: (funStr, sqltXet, params = [], poolID = 0)