fofstudio-aimcpztdata 1.0.0

package/build/modules/BufferClass.js

@@ -0,0 +1,6 @@
+exports.BufferClassToArrar = function (Data) {
+    return Array.from(new Uint8Array(Data))
+}
+exports.ArrarToBufferClass = function (Data) {
+    return Buffer.from(Data)
+}

package/build/modules/DataPackaging.js

@@ -0,0 +1,57 @@
+let Data = {};
+exports.NewID = function (ID, dataHead, dataEnd) {
+    try {
+        if (Data.length >= 500) {
+            for (let key in Data) {
+                delete Data[key];
+                break;
+            }
+        }
+        Data[ID] = {
+            "data1": [],
+            "dataHead": dataHead,
+            "dataEnd": dataEnd
+        };
+    } catch (error) {
+
+    }
+}
+exports.InsertData = function (ID, Data_) {
+    try {
+        if (Data[ID] != undefined) {
+            Data[ID].data1.splice(Data[ID].data1.length, 0, ...Array.from(new Uint8Array(Data_)));
+        }
+    } catch (error) {
+
+    }
+}
+exports.SelectData = function (ID) {
+    try {
+        Data[ID].data1.splice(0, Data[ID].dataHead.length)
+        Data[ID].data1.splice(Data[ID].data1.length - Data[ID].dataEnd.length, Data[ID].dataEnd.length)
+        return Buffer.from(Data[ID].data1)
+    } catch (error) {
+        return Buffer.from([])
+    }
+}
+exports.IFDataLength = function (ID) {
+    try {
+        let IfDataLength = true;
+        for (let index = 0; index < Data[ID].dataEnd.length; index++) {
+            if (Data[ID].data1[Data[ID].data1.length - index - 1] != Data[ID].dataEnd[Data[ID].dataEnd.length - index - 1]) {
+                IfDataLength = false;
+            }
+        }
+        return IfDataLength;
+    } catch (error) {
+
+    }
+    return false;
+}
+exports.DeleteData = function (ID) {
+    try {
+        delete Data[ID];
+    } catch (error) {
+
+    }
+}

package/build/modules/DecoderAPI.js

@@ -0,0 +1,30 @@
+exports.TextDecoder = (Decoder, Code, hexTrue = false, hexCode = "hex") => {
+	if (hexTrue == true) {
+		return Buffer.from(Code, hexCode).toString(Decoder)
+	}
+	const decoder = new TextDecoder(Decoder);
+	return decoder.decode(Code);
+}
+exports.TextDecoderBase64 = (Decoder, Code) => {
+	var b = new Buffer.from(Code, 'base64')
+	const decoder = new TextDecoder(Decoder);
+	let deCode = decoder.decode(b);
+	b = Buffer.from(deCode).toString('base64')
+	return b;
+}
+exports.TextToBase64 = (Code) => {
+	var b = Buffer.from(Code).toString('base64')
+	return b;
+}
+exports.Base64ToText = (Code) => {
+	var b = new Buffer.from(Code, 'base64')
+	return b.toString();
+}
+exports.TextTo16 = (Code) => {
+	var b = Buffer.from(Code).toString('hex')
+	return b;
+}
+exports.HexToText = (Code) => {
+	var b = new Buffer.from(Code, 'hex')
+	return b.toString();
+}

package/build/modules/DialogAPI.js

@@ -0,0 +1,48 @@
+const { dialog } = require('electron');
+exports.showOpenDialogSync = (data) => {
+    try {
+		let PathRet = dialog.showOpenDialogSync({
+			properties: ["openDirectory"],
+			title: data["名称"],
+			defaultPath: data["路径"],
+			buttonLabel: '确认选择'
+		});
+		return PathRet;
+	} catch (err) {
+		return "";
+	}
+}
+exports.showOpenDialogSyncFile = (data) => {
+    try {
+		let type = data["类型"];
+		if(type==2){
+			let PathRet = dialog.showOpenDialogSync({
+				properties: ["openDirectory"],
+				title: data["标题"],
+				defaultPath: data["路径"],
+				buttonLabel: data["按钮标题"]
+			});
+			return PathRet;
+		}else{
+			let filters = [];
+			for (let index = 0; index < data["过滤器"].length; index++) {
+				filters[filters.length] = { name: data["过滤器"][index]["名称"], extensions: data["过滤器"][index]["类型"] }
+			}
+			if (filters.length >= 1) {
+				type = ["openFile"]
+				let PathRet = dialog.showOpenDialogSync({
+					properties: type,
+					defaultPath: data["路径"],
+					title: data["标题"],
+					buttonLabel: data["按钮标题"],
+					filters: filters
+				})
+				return PathRet;
+			} else {
+				return [];
+			}
+		}
+	} catch (err) {
+		return [];
+	}
+}

package/build/modules/EXEAPI.js

@@ -0,0 +1,64 @@
+const { spawn } = require('child_process');
+let iconv = null;
+try {
+	iconv = require('iconv-lite');
+} catch (error) {
+
+}
+var spawnArr = [];//记录打开其他程序的对象
+exports.OpenEXE = (path) => {
+	try {
+		if (process.platform == 'darwin') {
+			var childSpawn = spawn(path + "/Contents/MacOS/Electron", [path], {
+				stdio: 'ignore',
+			});
+			spawnArr[spawnArr.length] = { "id": childSpawn, "type": 0 };
+			return path + "/Contents/MacOS/Electron";
+		} else {
+			var childSpawn = spawn(path);
+			spawnArr[spawnArr.length] = { "id": childSpawn, "type": 0 };
+			return spawnArr.length - 1;
+		}
+	} catch (error) {
+		return -1;
+	}
+}
+exports.KillEXE = (kill) => {
+	try {
+		if (spawnArr[kill]["type"] == 0) {
+			spawnArr[kill]["id"].kill();
+			spawnArr[kill]["type"] = -1;
+		}
+	} catch (error) {
+
+	}
+}
+exports.DoesTheProcessExist = (query, cb, encoding = "GBK") => {
+	const execs = require('child_process').exec;
+	let platform = process.platform;
+	let cmd = '';
+	switch (platform) {
+		case 'win32': cmd = `tasklist`; break;
+		case 'darwin': cmd = `ps -ax | grep ${query}`; break;
+		case 'linux': cmd = `ps -A`; break;
+		default: break;
+	}
+	let cwd = {
+		cwd: "",
+		encoding: "GBK",
+	}
+	execs(cmd, cwd, (err, stdout, stderr) => {
+		try {
+			const utf8Stdout = iconv.decode(Buffer.from(stdout, 'binary'), encoding);
+			if (cmd.indexOf("ps -ax |") != -1) {
+				cb(utf8Stdout.toLowerCase().indexOf(query.toLowerCase()) > -1 && utf8Stdout.toLowerCase().indexOf("applications") > -1);
+			} else {
+				cb(utf8Stdout.toLowerCase().indexOf(query.toLowerCase()) > -1);
+			}
+		} catch (error) {
+			cb(false)
+		}
+
+	});
+}
+

package/build/modules/FOFTcp.js

@@ -0,0 +1,309 @@
+const net = require('net')
+let ServerArr = [];
+let IPBlacklist = [];
+var player = [];
+var idObj = {};
+exports.InsertIPBlacklist = function (ip) {
+    IPBlacklist[IPBlacklist.length] = ip;
+}
+exports.NewServer = function (ServerData, MsgFun = undefined) {
+    ServerArr[ServerArr.length] = null;
+    let IntServer = ServerArr.length - 1;
+    idObj[IntServer] = {};
+    ServerArr[IntServer] = net.createServer((socket) => {
+        socket.on('data', (dt) => {
+            for (let index = 0; index < IPBlacklist.length; index++) {
+                let IPStr = IPBlacklist[index];
+                if (IPStr == undefined) {
+                    continue;
+                }
+                if (socket.remoteFamily != undefined) {
+                    if (socket.remoteFamily == IPStr) {
+                        socket.destroy()
+                    }
+                }
+                if (socket.remoteAddress != undefined) {
+                    if (socket.remoteAddress == IPStr) {
+                        socket.destroy()
+                    }
+                }
+            }
+            if (MsgFun != undefined) {
+                let RetData = MsgFun({
+                    "状态": "收到数据",
+                    "本地端口地址": socket.localPort,
+                    "本地IP地址": socket.localAddress,
+                    "进程端口地址": socket.remotePort,
+                    "进程IP协议": socket.remoteFamily,
+                    "进程IP地址": socket.remoteAddress,
+                    "数据内容": dt,
+                    "id": socket.socketIdxos,
+                    "接收长度": socket.bytesRead
+                })
+                if (RetData == undefined) {
+                    RetData = {}
+                }
+                try {
+                    if (RetData["是否反馈"] != undefined) {
+                        if (RetData["是否反馈"] == true) {
+                            if (RetData["反馈数据"] != "") {
+                                socket.write(RetData["反馈数据"]);
+                            }
+                        }
+                    }
+                    if (RetData["是否断开"] != undefined) {
+                        if (RetData["是否断开"] == true) {
+                            socket.destroy()
+                        }
+                    }
+                } catch (err) {
+
+                }
+            }
+        })
+        socket.on('close', (dt) => {
+            ServerArr[IntServer].getConnections(function (err, count) {
+                try {
+                    delete idObj[IntServer][socket.socketIdxos]
+                } catch (error) {
+                    
+                }
+                if (MsgFun != undefined) {
+                    MsgFun({
+                        "状态": "客户下线",
+                        "连接总量": count,
+                        "本地端口地址": socket.localPort,
+                        "本地IP地址": socket.localAddress,
+                        "进程端口地址": socket.remotePort,
+                        "进程IP协议": socket.remoteFamily,
+                        "id": socket.socketIdxos,
+                        "进程IP地址": socket.remoteAddress
+                    })
+                }
+            });
+        })
+        socket.on('end', (dt) => {
+            let RetData = MsgFun({
+                "状态": "任务完毕",
+                "本地端口地址": socket.localPort,
+                "本地IP地址": socket.localAddress,
+                "进程端口地址": socket.remotePort,
+                "进程IP协议": socket.remoteFamily,
+                "id": socket.socketIdxos,
+                "进程IP地址": socket.remoteAddress
+            })
+            if (RetData == undefined) {
+                RetData = {}
+            }
+            try {
+                if (RetData["是否反馈"] != undefined) {
+                    if (RetData["是否反馈"] == true) {
+                        if (RetData["反馈数据"] != "") {
+                            socket.write(RetData["反馈数据"]);
+                        }
+                    }
+                }
+                if (RetData["是否断开"] != undefined) {
+                    if (RetData["是否断开"] == true) {
+                        socket.destroy()
+                    }
+                }
+            } catch (err) {
+
+            }
+        })
+
+    })
+    if (ServerData["端口"] == undefined) {
+        ServerData["端口"] = 3000
+    }
+    if (ServerData["地址"] == undefined) {
+        ServerData["地址"] = "0.0.0.0"
+    }
+    if (ServerData["最大连接数"] == undefined) {
+        ServerData["最大连接数"] = 1000;
+    }
+    ServerArr[IntServer].listen(ServerData["端口"], ServerData["地址"], () => {
+        ServerArr[IntServer].maxConnections = ServerData["最大连接数"];
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "启动服务成功" })
+        }
+    })
+    ServerArr[IntServer].on('connection', socket => {
+        //7.获取客户度接入的数量：
+        ServerArr[IntServer].getConnections(function (err, count) {
+            let socketIdxos = player.length + 1;
+            player[player.length] = socketIdxos
+            socket.socketIdxos = socketIdxos
+            idObj[IntServer][socketIdxos] = socket;
+            if (MsgFun != undefined) {
+                let RetData = MsgFun({
+                    "状态": "新的接入",
+                    "连接总量": count,
+                    "本地端口地址": socket.localPort,
+                    "本地IP地址": socket.localAddress,
+                    "进程端口地址": socket.remotePort,
+                    "远程IP协议": socket.remoteFamily,
+                    "id": socket.socketIdxos,
+                    "进程IP地址": socket.remoteAddress
+                })
+                if (RetData == undefined) {
+                    RetData = {}
+                }
+                if (RetData["是否反馈"] != undefined) {
+                    if (RetData["是否反馈"] == true) {
+                        if (RetData["反馈数据"] != "") {
+                            socket.write(RetData["反馈数据"]);
+                        }
+                    }
+                }
+                if (RetData["是否断开"] != undefined) {
+                    if (RetData["是否断开"] == true) {
+                        socket.destroy()
+                    }
+                }
+            }
+        });
+        if (ServerData["是否组包"] == undefined) {
+            ServerData["是否组包"] = false
+        }
+        if (ServerData["是否组包"] == true) {
+            socket.setNoDelay(true);
+        }
+    })
+    ServerArr[IntServer].on('close', () => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "服务器关闭" })
+        }
+    })
+    ServerArr[IntServer].on('drop', () => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "连接到达上限" })
+        }
+    })
+    ServerArr[IntServer].on('error', () => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "服务发生错误" })
+        }
+    })
+    return IntServer;
+}
+exports.ServerClose = function (server) {
+    if (server == undefined) {
+        return;
+    }
+    try {
+        let keys = Object.keys(idObj[server]); 
+        for (let index = 0; index < keys.length; index++) {
+            idObj[server][keys[index]].destroy()
+        } 
+    } catch (error) {
+        
+    }
+    ServerArr[server].close(() => {
+        try {
+            idObj[server] = {};
+        } catch (error) {
+            
+        }
+    });
+}
+exports.socketList = function (ServerIDInt) {
+    let retdata = [];
+    if (idObj[ServerIDInt]) {
+        for (let key in idObj[ServerIDInt]) {
+            retdata[retdata.length] = key;
+        }
+        return retdata;
+    }
+    return [];
+}
+exports.send = function (ServerIDInt, id, data) {
+    if (idObj[ServerIDInt]) {
+        if (idObj[ServerIDInt][id]) {
+            idObj[ServerIDInt][id].write(data)
+        }
+    }
+}
+exports.Disconnect = function (ServerIDInt, id) {
+    if (idObj[ServerIDInt]) {
+        if (idObj[ServerIDInt][id]) {
+            idObj[ServerIDInt][id].destroy()
+        }
+    }
+}
+
+
+exports.NewSocket = function (ServerData, MsgFun = undefined) {
+    if (ServerData["端口"] == undefined) {
+        ServerData["端口"] = 3000
+    }
+    if (ServerData["地址"] == undefined) {
+        ServerData["地址"] = "127.0.0.1"
+    }
+    ServerArr[ServerArr.length] = null;
+    let IntServer = ServerArr.length - 1;
+    //2.创建tcp客户端：net.Socket(obj)中可以传入一个obj对象，其属性分别为：fd文件描述、readable是否允许可读、writeable是否可写、allowHalfOpen:false时，tcp服务器接收到客户端发送的fin包后会回发，为true时不回发，前三个属性的默认值为false
+    ServerArr[IntServer] = new net.Socket()
+    //3.连接tcp服务器：
+    ServerArr[IntServer].connect(ServerData["端口"], ServerData["地址"], () => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "连接服务成功" })
+        }
+    })
+    ServerArr[IntServer].on('data', (dt) => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "收到数据", "数据内容": dt })
+        }
+    })
+    ServerArr[IntServer].on('end', () => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "任务完毕" })
+        }
+    })
+    ServerArr[IntServer].on('error', (Error) => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "发现客户端错误", "错误信息": Error })
+        }
+    })
+    ServerArr[IntServer].on('close', () => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "客户端被关闭" })
+        }
+    })
+
+    return IntServer;
+}
+exports.SocketWrite = function (IntServer, Data) {
+    if (IntServer == undefined || Data == undefined) {
+        return;
+    }
+    ServerArr[IntServer].write(Data)
+}
+exports.SocketReadyState = function (IntServer) {
+    if (IntServer == undefined) {
+        return;
+    }
+    if (ServerArr[IntServer].readyState == "opening") {
+        return "正在连接";
+    }
+    if (ServerArr[IntServer].readyState == "open") {
+        return "连接状态";
+    }
+    if (ServerArr[IntServer].readyState == "closed") {
+        return "断开状态";
+    }
+    if (ServerArr[IntServer].readyState == "readOnly") {
+        return "可读但不可写状态";
+    }
+    if (ServerArr[IntServer].readyState == "writeOnly") {
+        return "不可读写状态";
+    }
+    return ServerArr[IntServer].readyState;
+}
+exports.SocketDestroy = function (IntServer) {
+    if (IntServer == undefined) {
+        return;
+    }
+    ServerArr[IntServer].destroy()
+}

package/build/modules/FOFUDP.js

@@ -0,0 +1,78 @@
+const dgram = require('node:dgram');
+let ServerArr = [];
+exports.NewServer = function (port = 22333, MsgFun = undefined) {
+    ServerArr[ServerArr.length] = null;
+    let IntServer = ServerArr.length - 1;
+    ServerArr[IntServer] = dgram.createSocket('udp4');
+    // 发生异常时触发
+    ServerArr[IntServer].on('error', (err) => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "发生服务异常", "异常说明": err.stack })
+        }
+    });
+    // 收到消息时触发
+    ServerArr[IntServer].on('message', (msg, rinfo) => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "收到数据", "数据内容": msg, "地址信息": rinfo.address, "端口信息": rinfo.port, "整体信息": rinfo })
+        }
+    });
+    // 启动监听时触发
+    ServerArr[IntServer].on('listening', () => {
+        const address = ServerArr[IntServer].address();
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "启动监听成功", "地址信息": address.address, "端口信息": address.port })
+        }
+    });
+    ServerArr[IntServer].bind(port);
+    return IntServer;
+}
+exports.ServerClose = function (IntServer) {
+    ServerArr[IntServer].close();
+}
+exports.ServerSend = function (IntServer, data, address, port) {
+    ServerArr[IntServer].send(data, port, address)
+}
+exports.NewClient = function (MsgFun = undefined) {
+    ServerArr[ServerArr.length] = null;
+    let IntServer = ServerArr.length - 1;
+    ServerArr[IntServer] = dgram.createSocket('udp4');
+    ServerArr[IntServer].on('close', () => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "关闭客户端" })
+        }
+    });
+    ServerArr[IntServer].on('error', (err) => {
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "发生错误异常", "异常说明": err })
+        }
+    });
+    ServerArr[IntServer].on('message', (msg, rinfo) => {
+        if (msg == 'exit') {
+            if (MsgFun != undefined) {
+                MsgFun({ "状态": "接收数据异常" })
+            }
+        }
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "收到数据", "数据内容": msg, "地址信息": rinfo.address, "端口信息": rinfo.port, "整体信息": rinfo })
+        }
+    });
+    if (MsgFun != undefined) {
+        MsgFun({ "状态": "初始化UDP成功" })
+    }
+    return IntServer;
+}
+exports.ClientSend = function (IntServer, message, address, port, MsgFun = undefined) {
+    ServerArr[IntServer].send(message, port, address, (err) => {
+        if (err) {
+            if (MsgFun != undefined) {
+                MsgFun({ "状态": "发送数据失败", "错误原因": err })
+            }
+        }
+        if (MsgFun != undefined) {
+            MsgFun({ "状态": "发送数据成功" })
+        }
+    });
+}
+exports.ClientClose = function (IntServer) {
+    ServerArr[IntServer].close();
+}