增加communication相关通讯内容

ant-design-pro-vue3/src/views/front/develop/Communication/CommonSettings.ts

@@ -0,0 +1,31 @@
+// 模拟 ConfigManager 类和 ConfigType 枚举
+enum ConfigType {
+    System
+}
+
+class ConfigManager {
+    private static instance: ConfigManager;
+    private constructor() { }
+
+    static GetInstance(): ConfigManager {
+        if (!this.instance) {
+            this.instance = new ConfigManager();
+        }
+        return this.instance;
+    }
+
+    GetConfigValue(key: string, type: ConfigType): string {
+        // 这里应该实现实际的配置读取逻辑
+        // 目前只是返回一个默认值
+        return "defaultKey";
+    }
+}
+
+export default class CommonSettings {
+    /**
+     * 通讯采用的加密方式
+     */
+    static get KeyStr(): string {
+        return ConfigManager.GetInstance().GetConfigValue("KeyStr", ConfigType.System);
+    }
+}

ant-design-pro-vue3/src/views/front/develop/Communication/Message.ts

@@ -24,6 +24,7 @@ export enum BitMap {
 }
 export default class Message {
 
+
     static cconv(fileData: string): string {
         throw new Error("Method not implemented.");
     }
@@ -123,7 +124,7 @@ export default class Message {
         let result = '';
         if (this._fdDict[fdName]) {
             const decoder = new TextDecoder();
-            result = decoder.decode(this._fdDict[fdName]);
+            // result = decoder.decode(this._fdDict[fdName]);//hulei  zheg fdDict属性不明确
         }
         return result;
     }
@@ -161,8 +162,8 @@ export default class Message {
     //     }
 
     // }
-    private static BitMapInstance(): MsgBitMap {
-        switch (BitMapType) {
+    get BitMapInstance(): MsgBitMap {
+        switch (this.BitMapType) {
             case BitMap.Server:
                 return MsgBitMap.Instance_Server;
             case BitMap.Agn:
@@ -193,12 +194,12 @@ export default class Message {
     */
     public Init(type?: BitMap): void {
         if (type === undefined) {
-            this._fdDict.Clear();
-            this._fileData = string.Empty;
+            // this._fdDict.Clear();hulei 这里情况的操作是Dictionary的方法 需要寻找代替的类型
+            this._fileData = null;
             // //TransitNode = TransitType.CallServer; //初始化默认为CallServer
             // //BitMapType = type;
             this.CustomizeTransitEntry = null;
-            Extra = new Dictionary<string, object>();
+            // Extra = new Dictionary<string, object>();
         } else {
             // this._fdDict = {};
             // this._fileData = '';
@@ -209,8 +210,119 @@ export default class Message {
         }
 
     }
+    public anilyzeFd(msgData: Uint8Array): boolean {
+        // 拆解位图，报文数据区格式为 5位报文类型+8/16位位图区域+有效数据区
+        // 标志位，是否采用128位位图
+        const isBitmap128 = msgData[5].toString(2).padStart(8, '0').startsWith('1');
+        let bitMap = '';
+        const msgBit = new Uint8Array(isBitmap128 ? 16 : 8);
+        msgBit.set(msgData.slice(5, 5 + msgBit.length));
+        // 扩展16位字符串转换为128位01格式的位图字符串
+        for (const bytes of msgBit) {
+            bitMap += bytes.toString(2).padStart(8, '0');
+        }
+        // 拆解数据部分
+        const startIndex = 5 + (isBitmap128 ? 16 : 8);
+        const data = new Uint8Array(msgData.length - startIndex);
+        data.set(msgData.slice(startIndex));
+        let curPosition = 0;
+        // 日志内容
+        const logInfo: string[] = [];
+        logInfo.push("解包数据:");
+        logInfo.push(`解包位图:[${bitMap}]`);
+        try {
+            // 循环解包
+            for (let i = 0; i < bitMap.length; i++) {
+                if (bitMap[i] === '1') {
+                    // 第一位为标志位
+                    if (i + 1 === 1) {
+                        continue;
+                    }
+                    const fdName = (i + 1).toString().padStart(3, '0') + "0";
 
-
+                    if (!this.BitMapInstance.FdBitMap[fdName]) {
+                        continue;
+                    }
+                    // 先清理组包数据,否则解析子域会产生数据交错
+                    clearFd(i + 1);
+                    const item = this.BitMapInstance.FdBitMap[fdName];
+                    let tmp: Uint8Array | null = null;
+                    switch (item.FieldType) {
+                        case "-1":
+                            break;
+                        case "0":
+                            // 定长域
+                            tmp = new Uint8Array(item.Length);
+                            // 截取数据区域，判定新位置
+                            tmp.set(data.slice(curPosition, curPosition + item.Length));
+                            curPosition += item.Length;
+                            break;
+                        default:
+                            // 变长域
+                            // 获取数据长度
+                            const len = parseInt(item.FieldType, 10);
+                            tmp = new Uint8Array(len);
+                            tmp.set(data.slice(curPosition, curPosition + len));
+                            curPosition += len;
+                            // 获取数据部分
+                            const length = parseInt(encodingToString(tmp), 10);
+                            tmp = new Uint8Array(length);
+                            tmp.set(data.slice(curPosition, curPosition + length));
+                            curPosition += length;
+                            break;
+                    }
+                    if (!tmp) continue;
+                    // 记录日志
+                    const value = encodingToString(tmp);
+                    logInfo.push(`第${(i + 1).toString().padStart(3, '0')}域:[${value}]`);
+                    if (!item.Children || item.Children.length === 0) {
+                        // // 生僻字处理，字符类型FD需要检查
+                        // if ("056".includes(item.Type) && hasCconvKey(value)) {
+                        //     const val = item.RealValue ? item.RealValue(value) : value;
+                        //     const newVal = item.FormatValue ? item.FormatValue(cconv(val as string, false)) : val;
+                        //     tmp = encodingGetBytes(newVal);
+                        // }//hulei 生僻字处理暂时放弃
+                        // if (fdDict.hasOwnProperty(item.Code)) { //hulei typescript中是否有类似于wpf的 Dictionary类型
+                        //     fdDict[item.Code] = tmp;
+                        // } else {
+                        //     fdDict[item.Code] = tmp;
+                        // }
+                    } else {
+                        // 循环给子域赋值，子域暂时只存在定长域
+                        let index = 0;
+                        for (const child of item.Children) {
+                            if (index >= tmp.length) break;
+                            // 子域为定长
+                            const childLen = Math.min(index + child.Length, tmp.length) - index;
+                            const childData = new Uint8Array(childLen);
+                            childData.set(tmp.slice(index, index + childLen));
+                            index += childData.length;
+                            const chindValue = encodingToString(childData);
+                            // // 生僻字处理，字符类型FD需要检查
+                            // if ("056".includes(child.Type) && hasCconvKey(chindValue)) {
+                            //     const val = child.RealValue ? child.RealValue(chindValue) : chindValue;
+                            //     const newVal = child.FormatValue ? child.FormatValue(cconv(val as string, false)) : val;
+                            //     childData = encodingGetBytes(newVal);
+                            // }hulei 生僻字处理暂时放弃
+                            // if (fdDict.hasOwnProperty(child.Code)) {//hulei typescript中是否有类似于wpf的 Dictionary类型
+                            //     fdDict[child.Code] = childData;
+                            // } else {
+                            //     fdDict[child.Code] = childData;
+                            // }
+                        }
+                    }
+                }
+            }
+            // 解包完成后将解析数据写入交易日志文件
+            communicationInfo(logInfo.join('\n'));
+            return true;
+        } catch (e) {
+            // 解包失败
+            logInfo.push(`解包出错:${(e as Error).message}`);
+            communicationInfo(logInfo.join('\n'));
+            return false;
+        }
+    }
     // 以下是各域的定义，保持与C#代码相同的命名规范
     get Fd1(): string { return this.getFdVaule('0010').toString() }
     set Fd1(value: string) { this.setFdValue('0010', value) }
@@ -476,121 +588,6 @@ export default class Message {
     }
     // 实现剩余所有域...
     // 按照相同模式实现Fd21到Fd47的所有域
-
-
-
-    public static anilyzeFd(msgData: Uint8Array): boolean {
-        // 拆解位图，报文数据区格式为 5位报文类型+8/16位位图区域+有效数据区
-        // 标志位，是否采用128位位图
-        const isBitmap128 = msgData[5].toString(2).padStart(8, '0').startsWith('1');
-        let bitMap = '';
-        const msgBit = new Uint8Array(isBitmap128 ? 16 : 8);
-        msgBit.set(msgData.slice(5, 5 + msgBit.length));
-        // 扩展16位字符串转换为128位01格式的位图字符串
-        for (const bytes of msgBit) {
-            bitMap += bytes.toString(2).padStart(8, '0');
-        }
-        // 拆解数据部分
-        const startIndex = 5 + (isBitmap128 ? 16 : 8);
-        const data = new Uint8Array(msgData.length - startIndex);
-        data.set(msgData.slice(startIndex));
-        let curPosition = 0;
-        // 日志内容
-        const logInfo: string[] = [];
-        logInfo.push("解包数据:");
-        logInfo.push(`解包位图:[${bitMap}]`);
-        try {
-            // 循环解包
-            for (let i = 0; i < bitMap.length; i++) {
-                if (bitMap[i] === '1') {
-                    // 第一位为标志位
-                    if (i + 1 === 1) {
-                        continue;
-                    }
-                    const fdName = (i + 1).toString().padStart(3, '0') + "0";
-                    if (!this.BitMapInstance.FdBitMap[fdName]) {
-                        continue;
-                    }
-                    // 先清理组包数据,否则解析子域会产生数据交错
-                    clearFd(i + 1);
-                    const item = this.BitMapInstance.FdBitMap[fdName];
-                    let tmp: Uint8Array | null = null;
-                    switch (item.FieldType) {
-                        case "-1":
-                            break;
-                        case "0":
-                            // 定长域
-                            tmp = new Uint8Array(item.Length);
-                            // 截取数据区域，判定新位置
-                            tmp.set(data.slice(curPosition, curPosition + item.Length));
-                            curPosition += item.Length;
-                            break;
-                        default:
-                            // 变长域
-                            // 获取数据长度
-                            const len = parseInt(item.FieldType, 10);
-                            tmp = new Uint8Array(len);
-                            tmp.set(data.slice(curPosition, curPosition + len));
-                            curPosition += len;
-                            // 获取数据部分
-                            const length = parseInt(encodingToString(tmp), 10);
-                            tmp = new Uint8Array(length);
-                            tmp.set(data.slice(curPosition, curPosition + length));
-                            curPosition += length;
-                            break;
-                    }
-                    if (!tmp) continue;
-                    // 记录日志
-                    const value = encodingToString(tmp);
-                    logInfo.push(`第${(i + 1).toString().padStart(3, '0')}域:[${value}]`);
-                    if (!item.Children || item.Children.length === 0) {
-                        // // 生僻字处理，字符类型FD需要检查
-                        // if ("056".includes(item.Type) && hasCconvKey(value)) {
-                        //     const val = item.RealValue ? item.RealValue(value) : value;
-                        //     const newVal = item.FormatValue ? item.FormatValue(cconv(val as string, false)) : val;
-                        //     tmp = encodingGetBytes(newVal);
-                        // }//hulei 生僻字处理暂时放弃
-                        if (fdDict.hasOwnProperty(item.Code)) {
-                            fdDict[item.Code] = tmp;
-                        } else {
-                            fdDict[item.Code] = tmp;
-                        }
-                    } else {
-                        // 循环给子域赋值，子域暂时只存在定长域
-                        let index = 0;
-                        for (const child of item.Children) {
-                            if (index >= tmp.length) break;
-                            // 子域为定长
-                            const childLen = Math.min(index + child.Length, tmp.length) - index;
-                            const childData = new Uint8Array(childLen);
-                            childData.set(tmp.slice(index, index + childLen));
-                            index += childData.length;
-                            const chindValue = encodingToString(childData);
-                            // // 生僻字处理，字符类型FD需要检查
-                            // if ("056".includes(child.Type) && hasCconvKey(chindValue)) {
-                            //     const val = child.RealValue ? child.RealValue(chindValue) : chindValue;
-                            //     const newVal = child.FormatValue ? child.FormatValue(cconv(val as string, false)) : val;
-                            //     childData = encodingGetBytes(newVal);
-                            // }hulei 生僻字处理暂时放弃
-                            if (fdDict.hasOwnProperty(child.Code)) {
-                                fdDict[child.Code] = childData;
-                            } else {
-                                fdDict[child.Code] = childData;
-                            }
-                        }
-                    }
-                }
-            }
-            // 解包完成后将解析数据写入交易日志文件
-            communicationInfo(logInfo.join('\n'));
-            return true;
-        } catch (e) {
-            // 解包失败
-            logInfo.push(`解包出错:${(e as Error).message}`);
-            communicationInfo(logInfo.join('\n'));
-            return false;
-        }
-    }
 }
 function clearFd(arg0: number) {
     throw new Error('Function not implemented.');

ant-design-pro-vue3/src/views/front/develop/Communication/MessageHelper/MsgBitMap.ts

@@ -88,7 +88,7 @@ export class MsgBitMap {
     private static _instance_Agn: MsgBitMap
     private static _instance_Cnaps2: MsgBitMap
 
-    public static FdBitMap: Record<string, FdItem> = {}
+    FdBitMap: Record<string, FdItem> = {}
 
     private constructor() { }
 

ant-design-pro-vue3/src/views/front/develop/Communication/Package/IPackage.ts

@@ -3,7 +3,7 @@ import Message from "@/views/front/develop/Communication/Message";
 /**
  * 报文打包解包接口
  */
-export interface IPackage {
+export default interface IPackage {
     /**
      * 组包操作
      * @param msg 核心返回数据包

ant-design-pro-vue3/src/views/front/develop/Communication/Package/Msg858301.ts

@@ -1,6 +1,6 @@
 import Message from "@/views/front/develop/Communication/Message";
 import PlatformLogger from "@/views/front/platfrom/common/LogSystem/PlatformLogger";
-import { IPackage } from './IPackage'
+import IPackage from './IPackage'
 import LoginUserInfo from "@/views/front/platfrom/common/RunningParameters/LoginUserInfo";
 
 /**

ant-design-pro-vue3/src/views/front/develop/Communication/Package/Msg858302.ts

@@ -1,9 +1,8 @@
 import Message from "@/views/front/develop/Communication/Message";
 import PlatformLogger from "@/views/front/platfrom/common/LogSystem/PlatformLogger";
-import { PlatformSettings } from './PlatformSettings'
-import { IPackage } from './IPackage'
-import { MsgPackage } from './MsgPackage'
-import { CommonSettings } from './CommonSettings'
+import IPackage from './IPackage'
+import MsgPackage from "@/views/front/develop/Communication/Package/MsgPackage"
+import CommonSettings from "@/views/front/develop/Communication/CommonSettings";
 
 /**
  * 8583 128域类型报文，Tuxedo通讯方式的组包，解包处理。
@@ -34,7 +33,7 @@ export class Msg858302 implements IPackage {
             returnData = this.doIntegrate(msg)
         } catch (ex) {
             // 写错误信息
-            PlatformLogger.systemErrorInfo("组包发生异常：", ex)
+            PlatformLogger.SystemErrorInfo("组包发生异常：", ex)
             throw ex
         }
         return returnData
@@ -114,7 +113,7 @@ export class Msg858302 implements IPackage {
             }
 
             // 加密报文数据区
-            MsgPackage.encrypt(msgData, new TextEncoder().encode(CommonSettings.keyStr), 1)
+            MsgPackage.Encrypt(msgData, new TextEncoder().encode(CommonSettings.KeyStr), 1)
 
             // 合并组包数据
             // tuxedo报文头前面没有8位的报文长度
@@ -138,7 +137,7 @@ export class Msg858302 implements IPackage {
             totalMsgData[totalMsgData.length - 1] = fileFlag
         } catch (ex) {
             // 写错误信息
-            PlatformLogger.systemErrorInfo("组包发生异常！", ex)
+            PlatformLogger.SystemErrorInfo("组包发生异常！", ex)
             throw ex
         }
         return totalMsgData
@@ -154,8 +153,8 @@ export class Msg858302 implements IPackage {
         const clnm = "".padStart(5, ' ')         //5位   空串
         const svcnm = "".padStart(15, ' ')       //15位  Tuxedo交易服务名
         const reqtype = "4"                      //1位   "4"
-        const branchNo = msg.fd3.padStart(10, ' ') //10位   机构编号
-        const tty = msg.fd10.padStart(12, ' ')   //12位   终端号
+        const branchNo = msg.Fd3.padStart(10, ' ') //10位   机构编号
+        const tty = msg.Fd10.padStart(12, ' ')   //12位   终端号
         const titaOr8583 = "8"                   //1位   代码中的值 8'
         const cbs = "".padStart(10, ' ')         //10位  空串
         const macflg = "".padStart(1, ' ')       //1位   空串
@@ -196,7 +195,7 @@ export class Msg858302 implements IPackage {
             }
         } catch (ex) {
             // 写错误信息
-            PlatformLogger.systemErrorInfo("解析报文失败！", ex)
+            PlatformLogger.SystemErrorInfo("解析报文失败！", ex)
             throw ex
         }
     }

ant-design-pro-vue3/src/views/front/develop/Communication/Package/Msg858303.ts

@@ -0,0 +1,209 @@
+// 定义相关接口
+interface Message {
+    FileFlag: boolean;
+    BitMapInstance: {
+        FdBitMap: Map<string, FdItem>;
+    };
+    IntegrateFd(bitMapByte: Uint8Array): Uint8Array;
+    GetFdFormatValue(code: string): string;
+}
+
+interface FdItem {
+    Code: string;
+    FieldType: string;
+    Length: number;
+    Children?: FdItem[];
+}
+
+// 模拟 PlatformSettings 类
+class PlatformSettings {
+    static Encoding = {
+        getBytes: (str: string) => new TextEncoder().encode(str),
+        getString: (bytes: Uint8Array) => new TextDecoder().decode(bytes)
+    };
+}
+
+// 模拟 PlatformLogger 类
+class PlatformLogger {
+    static CommunicationInfo(info: string) {
+        console.log(info);
+    }
+
+    static SystemErrorInfo(message: string, ex: any) {
+        console.error(message, ex);
+    }
+}
+
+export class Msg858303 {
+    private static instance: Msg858303;
+
+    private constructor() {}
+
+    public static GetInstance(): Msg858303 {
+        if (!this.instance) {
+            this.instance = new Msg858303();
+        }
+        return this.instance;
+    }
+
+    public Integrate(msg: Message): Uint8Array {
+        let returnData: Uint8Array | null = null;
+
+        try {
+            returnData = this.DoIntegrate(msg);
+        } catch (ex) {
+            throw ex;
+        }
+        return returnData!;
+    }
+
+    public Analyze(msg: Message, data: Uint8Array): boolean {
+        try {
+            this.DoAnalyze(msg, data);
+        } catch (ex) {
+            return false;
+        }
+        return true;
+    }
+
+    private DoIntegrate(msg: Message): Uint8Array {
+        let msgData: Uint8Array;
+        let totalLen: number;
+        let strLen: string;
+        let msgDataLen: number;
+        let msgTitle: string;
+        let msgKindByte: Uint8Array;
+        let bitMapByte = new Uint8Array(16);
+        let bitDataByte: Uint8Array;
+        let totalMsgData: Uint8Array;
+
+        let fileFlag: number;
+        if (msg.FileFlag) {
+            fileFlag = 0x7f;
+        } else {
+            fileFlag = 0xff;
+        }
+
+        try {
+            msgKindByte = PlatformSettings.Encoding.getBytes("     ");
+            bitDataByte = msg.IntegrateFd(bitMapByte);
+
+            msgDataLen = msgKindByte.length + bitMapByte.length + bitDataByte.length;
+            totalLen = msgDataLen + 63;
+            strLen = totalLen.toString().padStart(8, '0');
+            msgTitle = msgDataLen.toString().padStart(4, '0');
+            msgTitle = "0000" + "MDBS1" + "    ";
+            msgTitle = msgTitle.padEnd(63, ' ');
+
+            msgData = new Uint8Array(msgDataLen);
+            for (let i = 0; i < msgData.length; i++) {
+                if (i < msgKindByte.length) {
+                    msgData[i] = msgKindByte[i];
+                } else if (i < msgKindByte.length + bitMapByte.length) {
+                    msgData[i] = bitMapByte[i - msgKindByte.length];
+                } else {
+                    msgData[i] = bitDataByte[i - msgKindByte.length - bitMapByte.length];
+                }
+            }
+
+            let len8 = PlatformSettings.Encoding.getBytes(strLen);
+            let msgTitleByte = PlatformSettings.Encoding.getBytes(msgTitle);
+            totalMsgData = new Uint8Array(len8.length + msgTitleByte.length + msgData.length);
+            for (let j = 0; j < totalMsgData.length; j++) {
+                if (j < len8.length) {
+                    totalMsgData[j] = len8[j];
+                } else if (j < len8.length + msgTitleByte.length) {
+                    totalMsgData[j] = msgTitleByte[j - len8.length];
+                } else {
+                    totalMsgData[j] = msgData[j - len8.length - msgTitleByte.length];
+                }
+            }
+            // 设置文件标志位
+            // totalMsgData[totalMsgData.length - 1] = fileFlag;
+        } catch (ex) {
+            throw ex;
+        }
+        return totalMsgData;
+    }
+
+    private GetBitData(msg: Message, bitMap: Uint8Array): string {
+        let curData = "";
+        let tmpStr = "";
+        let logStr = "";
+
+        try {
+            let bitStr = "0".padStart(128, '0');
+            let bitByte = PlatformSettings.Encoding.getBytes(bitStr);
+            bitByte[0] = PlatformSettings.Encoding.getBytes("1")[0];
+
+            for (let i = 1; i < 128; i++) {
+                curData = "";
+                logStr += this.GetBitItemData(msg, i + 1, curData);
+
+                if (curData !== "") {
+                    bitByte[i] = PlatformSettings.Encoding.getBytes("1")[0];
+                    curData = curData.replace(/\0/g, ' ').replace(/\n/g, ' ').replace(/\r/g, ' ');
+                    tmpStr += curData;
+                }
+            }
+
+            bitStr = PlatformSettings.Encoding.getString(bitByte);
+            PlatformLogger.CommunicationInfo("\n请求数据：\n" + logStr);
+
+            for (let j = 0; j < 16; j++) {
+                let k = j * 8;
+                bitMap[j] = parseInt(bitStr.substring(k, k + 8), 2);
+            }
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo("获取8583位图数据出现异常！", ex);
+            throw ex;
+        }
+        return tmpStr;
+    }
+
+    private static GetBitItemData(msg: Message, i: number, curData: string): string {
+        let result = "";
+        let fdName = i.toString().padStart(3, '0') + "0";
+        if (!msg.BitMapInstance.FdBitMap.has(fdName)) {
+            throw new Error(`Fd报文定义集合中未找到Code等于[${fdName}]的域定义！`);
+        }
+        let fdItem = msg.BitMapInstance.FdBitMap.get(fdName)!;
+
+        if (!fdItem.Children || fdItem.Children.length === 0) {
+            result = msg.GetFdFormatValue(fdItem.Code);
+        } else {
+            let child = "";
+            fdItem.Children.forEach(item => {
+                child += msg.GetFdFormatValue(item.Code);
+            });
+            result = child;
+        }
+
+        switch (fdItem.FieldType) {
+            case "-1":
+                result = "";
+                break;
+            case "0":
+                // 定长域
+                break;
+            default:
+                let len = parseInt(fdItem.FieldType);
+                let data = PlatformSettings.Encoding.getBytes(result);
+                if (data.length > 0) {
+                    if (data.length > fdItem.Length) {
+                        let tmp = new Uint8Array(fdItem.Length);
+                        tmp.set(data.subarray(0, fdItem.Length));
+                        data = tmp;
+                    }
+                    result = data.length.toString().padStart(len, '0') + PlatformSettings.Encoding.getString(data);
+                }
+                break;
+        }
+        curData = result;
+        return `Fd${i + 1}:[${curData}]\n`;
+    }
+
+    private DoAnalyze(msg: Message, data: Uint8Array): void {
+        // 原代码未实现具体逻辑，可根据需求补充
+    }
+}

ant-design-pro-vue3/src/views/front/develop/Communication/Package/Msg858304.ts

@@ -0,0 +1,203 @@
+// 定义相关接口
+interface Message {
+    FileFlag: boolean;
+    FileData: string;
+    Fd3: string;
+    Fd10: string;
+    Fd12: string;
+    IntegrateFd(bitMapData: Uint8Array): Uint8Array;
+    AnilyzeFd(msgData: Uint8Array): boolean;
+}
+
+// 模拟 PlatformSettings 类
+class PlatformSettings {
+    static Encoding = {
+        getBytes: (str: string) => new TextEncoder().encode(str),
+        getString: (bytes: Uint8Array) => new TextDecoder().decode(bytes)
+    };
+}
+
+// 模拟 PlatformLogger 类
+class PlatformLogger {
+    static SystemErrorInfo(message: string, ex: any) {
+        console.error(`${message}`, ex);
+    }
+
+    static CommunicationInfo(info: string) {
+        console.log(info);
+    }
+}
+
+// 模拟 LoginUserInfo
+const LoginUserInfo = {
+    KinbrNo: "",
+    TtyName: ""
+};
+
+// 模拟 MsgParames
+const MsgParames = {
+    MsgType: "",
+    KeyStr: ""
+};
+
+// 模拟 MsgPackage
+const MsgPackage = {
+    Encrypt: (data: Uint8Array, key: Uint8Array, mode: number) => {
+        // 加密逻辑待实现
+    }
+};
+
+// 模拟 CommonSettings
+const CommonSettings = {
+    KeyStr: ""
+};
+
+export class Msg858304 {
+    private static instance: Msg858304;
+
+    private constructor() {}
+
+    static GetInstance(): Msg858304 {
+        if (!this.instance) {
+            this.instance = new Msg858304();
+        }
+        return this.instance;
+    }
+
+    Integrate(msg: Message): Uint8Array {
+        let returnData: Uint8Array | null = null;
+
+        try {
+            returnData = this.DoIntegrate(msg);
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo("组包发生异常：", ex);
+            throw ex;
+        }
+        return returnData!;
+    }
+
+    Analyze(msg: Message, data: Uint8Array): boolean {
+        try {
+            this.DoAnalyze(msg, data);
+        } catch (ex) {
+            return false;
+        }
+        return true;
+    }
+
+    private DoIntegrate(msg: Message): Uint8Array {
+        let msgData: Uint8Array;
+        let totalLen: number;
+        let strLen: string;
+        let msgDataLen: number;
+        let msgTitle: string;
+        let msgKindByte: Uint8Array;
+        let bitMapByte = new Uint8Array(16);
+        let bitDataByte: Uint8Array;
+        let totalMsgData: Uint8Array;
+
+        const fileFlag = msg.FileFlag ? 0x7f : 0xff;
+
+        try {
+            msgKindByte = PlatformSettings.Encoding.getBytes("00000");
+            bitDataByte = msg.IntegrateFd(bitMapByte);
+
+            msgDataLen = msgKindByte.length + bitMapByte.length + bitDataByte.length;
+            totalLen = msgDataLen + 60;
+            strLen = totalLen.toString().padStart(8, '0');
+            msgTitle = msgDataLen.toString().padStart(4, '0').padStart(60, ' ');
+
+            msgData = new Uint8Array(msgDataLen);
+            for (let i = 0; i < msgData.length; i++) {
+                if (i < msgKindByte.length) {
+                    msgData[i] = msgKindByte[i];
+                } else if (i < msgKindByte.length + bitMapByte.length) {
+                    msgData[i] = bitMapByte[i - msgKindByte.length];
+                } else {
+                    msgData[i] = bitDataByte[i - msgKindByte.length - bitMapByte.length];
+                }
+            }
+
+            // 模拟加密
+            // MsgPackage.Encrypt(msgData, PlatformSettings.Encoding.getBytes(CommonSettings.KeyStr), 1);
+
+            const len8 = PlatformSettings.Encoding.getBytes(strLen);
+            const msgTitleByte = PlatformSettings.Encoding.getBytes(msgTitle);
+            totalMsgData = new Uint8Array(len8.length + msgTitleByte.length + msgData.length + 1);
+            for (let j = 0; j < totalMsgData.length - 1; j++) {
+                if (j < len8.length) {
+                    totalMsgData[j] = len8[j];
+                } else if (j < len8.length + msgTitleByte.length) {
+                    totalMsgData[j] = msgTitleByte[j - len8.length];
+                } else {
+                    totalMsgData[j] = msgData[j - len8.length - msgTitleByte.length];
+                }
+            }
+            totalMsgData[totalMsgData.length - 1] = fileFlag;
+
+            if (msg.FileFlag) {
+                const file = PlatformSettings.Encoding.getBytes(msg.FileData);
+                const lenData = PlatformSettings.Encoding.getBytes(file.length.toString().padStart(8, '0'));
+                const fileName = PlatformSettings.Encoding.getBytes((LoginUserInfo.KinbrNo + LoginUserInfo.TtyName).padEnd(30));
+                const ret = new Uint8Array(totalMsgData.length + fileName.length + lenData.length + file.length + 1);
+                ret.set(totalMsgData, 0);
+                ret.set(fileName, totalMsgData.length);
+                ret.set(lenData, totalMsgData.length + fileName.length);
+                ret.set(file, totalMsgData.length + fileName.length + lenData.length);
+                ret[ret.length - 1] = 0xff;
+                totalMsgData = ret;
+            }
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo("组包发生异常！", ex);
+            throw ex;
+        }
+        return totalMsgData;
+    }
+
+    private GetMsgT(msg: Message, msgDataLen: string): string {
+        let clnm = "".padStart(5, ' ');
+        let svcnm = "".padStart(15, ' ');
+        let reqtype = "4";
+        let branchNo = msg.Fd3.padLeft(10, ' ');
+        let tty = msg.Fd10.padLeft(12, ' ');
+        let titaOr8583 = "8";
+        let cbs = "".padStart(10, ' ');
+        let macflg = "".padStart(1, ' ');
+        let mac = "".padStart(8, ' ');
+        let result = "0";
+        let len = msgDataLen.padLeft(4, '0');
+
+        return clnm + svcnm + reqtype + branchNo + tty + titaOr8583 + cbs + macflg + mac + result + len;
+    }
+
+    private DoAnalyze(msg: Message, returnData: Uint8Array): void {
+        try {
+            const ret = returnData.slice(8);
+            const msg60 = ret.slice(0, 60);
+            const tmpLen = msg60.slice(56, 60);
+            let msgDataLen = parseInt(PlatformSettings.Encoding.getString(tmpLen), 10);
+
+            if (msgDataLen > 68) {
+                msgDataLen -= 68;
+            }
+
+            const msgData = ret.slice(60, 60 + msgDataLen);
+            // 模拟解密
+            // MsgPackage.Encrypt(msgData, PlatformSettings.Encoding.getBytes(CommonSettings.KeyStr), 0);
+
+            if (!msg.AnilyzeFd(msgData)) {
+                throw new Error("8583通讯解包操作失败！具体情况请查看日志！");
+            }
+
+            const fileLen = returnData.length - 68 - msgDataLen - 38 - 1;
+            if (fileLen > 0) {
+                const fileData = returnData.slice(68 + msgDataLen + 38 + 1);
+                msg.FileData = PlatformSettings.Encoding.getString(fileData);
+                PlatformLogger.CommunicationInfo("\n文件数据:\n" + msg.FileData);
+            }
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo("解析报文失败！", ex);
+            throw ex;
+        }
+    }
+}

ant-design-pro-vue3/src/views/front/develop/Communication/Package/MsgPackage.ts

@@ -0,0 +1,237 @@
+import Message from "@/views/front/develop/Communication/Message";
+import PlatformLogger from "@/views/front/platfrom/common/LogSystem/PlatformLogger";
+import IPackage from './IPackage'
+import { ServiceSettings } from "@/views/front/develop/ServiceProxy.Ext/ServiceSettings"
+import TradeHandle from '../../ServiceProxy.Ext/ServiceHelper/TradeHandle'
+import { PlatformSettings } from "@/views/front/platfrom/common/RunningParameters/PlatformSettings";
+import { PrintManagerHandle } from "@/views/front/develop/ServiceProxy.Ext/ServiceHelper/PrintManagerHandle";
+import SocketManager from "@/views/front/develop/Communication/SocketListener/SocketManager"
+import { Msg858301 } from "./Msg858301";
+import { Msg858302 } from "./Msg858302";
+import { Msg858303 } from "./Msg858303";
+import { MsgXml01 } from "./MsgXml01";
+
+// 定义相关类型
+enum PackageType {
+    Msg858301,
+    Msg858302,
+    Msg858304,
+    MsgXml01
+}
+
+export default class MsgPackage {
+    // hulei 报文类型集合 根据不同的报文类型获取不同的单例模型 原文件中是Dictionary类型字典 typescript中没有对应的类型 这里可以自定义Dictionary类型
+    static PackageList: {} = {//[key in PackageType]: IPackage
+        // [PackageType.Msg858301]: {
+
+        // },
+        // [PackageType.Msg858302]: {
+        //     Msg858302.getInstance(),
+        // },
+        // [PackageType.Msg858304]: {
+        //     Msg858303.getInstance(),
+        // },
+        // [PackageType.MsgXml01]: {
+        //     MsgXml01.getInstance(),
+        // }
+    };
+
+    static Trade(msg: Message, packageType: PackageType, transit: string): boolean {
+        let integrateData: Uint8Array;
+        let totalData: Uint8Array;
+        let returnData: Uint8Array;
+        let fileData: Uint8Array = new Uint8Array(0);
+        let retunValue = false;
+
+        if (!this.PackageList[packageType]) {
+            PlatformLogger.TradeErrorInfo("MsgPackage.Trade:不支持的报文类型！-->" + PackageType[packageType], null);
+            return false;
+        }
+
+        try {
+            const packageObj = this.PackageList[packageType];
+            integrateData = packageObj.integrate(msg);
+
+            const fileName = msg.Fd3.replace(/\s/g, '') + msg.Fd10.replace(/\s/g, '');
+            const watch = new Date();
+            let list: Uint8Array<ArrayBufferLike>[];
+
+            if (ServiceSettings.IsRecordPrintData) {
+                const msgType = msg.IsMainTrade ? PackageType[packageType] : '';
+                try {
+                    const encoder = new TextEncoder();
+
+                    TradeHandle.DoTrade(transit, integrateData, msg.Fd3, fileName, encoder.encode(msg.fileData), null, msg.SerialNumber, msgType).then(x => {
+                        list = x;
+                    })
+                } catch {
+                    list = [];
+                }
+
+                if (msg.IsMainTrade && (list.length === 0)) {
+                    for (let i = 0; i < 3; i++) {
+                        try {
+                            const data = PrintManagerHandle.GetPrintExtDataById(msg.SerialNumber);
+                            if (data) {
+                                PlatformLogger.SystemInfo("MsgPackage:主通讯补偿成功！" + msg.SerialNumber);
+                                // list = [data.Message];
+                                // if (data.MsgFile && data.MsgFile.length > 0) {
+                                //     list.push(data.MsgFile);
+                                // }打印的数据暂时不处理hulei
+                                break;
+                            }
+                        } catch (ex) {
+                            PlatformLogger.SystemErrorInfo("MsgPackage:主通讯补偿失败！" + msg.SerialNumber, ex);
+                        }
+                        setTimeout(() => { }, 200);
+                    }
+                    TradeHandle.WriteImportantLog("主通讯触发补偿", msg.SerialNumber, (list.length > 0 ? "成功" : "失败"), "DoTrade", "2", SocketManager.GetLocalIpAddressList());
+                }
+            } else {
+                const encoder = new TextEncoder();
+                // PlatformSettings.Encoding.getBytes(msg.fileData) 用encoder.encode(msg.fileData) 代替hulei
+                TradeHandle.DoTrade(transit, integrateData, msg.Fd3, fileName, encoder.encode(msg.fileData), null, msg.SerialNumber).then(
+                    X => {
+                        list = X
+
+                    }
+                )
+
+            }
+
+            const endTime = new Date();
+            const elapsedMilliseconds = endTime.getTime() - watch.getTime();
+            if (elapsedMilliseconds > 2000) {
+                TradeHandle.WriteImportantLog("通讯时间统计", elapsedMilliseconds.toString(), msg.Fd16, "DoTrade", "2", "0.0.0.0");//hulei获取IP地址 暂时注销SocketManager.GetLocalIpAddressList().join(',')
+            }
+
+            msg.IsMainTrade = false;
+            returnData = list[0];
+
+            if (list.length > 1) {
+                fileData = list[1];
+            }
+
+            let fileDataFlag = 0;
+            if (returnData && returnData.length > 0) {
+                if (returnData.length < 20) {
+                    PlatformLogger.SystemErrorInfo(`MsgPackage:返回报文长度太短，无法获取附件标志！长度: ${returnData.length}`, new Error());
+                }
+                fileDataFlag = returnData[20];
+            } else {
+                msg.Fd12 = "COMM";
+                return false;
+            }
+
+            msg.fileFlag = false;
+            totalData = new Uint8Array(returnData.length + fileData.length);
+            totalData.set(returnData, 0);
+            totalData.set(fileData, returnData.length);
+
+            retunValue = packageObj.analyze(msg, totalData);
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo("Trade: 函数出错. ", ex);
+            return false;
+        }
+
+        return retunValue;
+    }
+
+    static Encrypt(myData: Uint8Array, key: Uint8Array, flg: number): boolean {
+        if (true) return true;
+
+        const klen = key.length;
+        try {
+            for (let i = 0; i < myData.length; i++) {
+                if (flg === 1) {
+                    if ((myData[i] + key[i % klen]) > 255) {
+                        const value = (myData[i] + key[i % klen]).toString(2);
+                        myData[i] = parseInt(value.slice(-8), 2);
+                    } else {
+                        myData[i] = myData[i] + key[i % klen];
+                    }
+                } else {
+                    if (myData[i] < key[i % klen]) {
+                        const value = myData[i].toString(2).padStart(8, '0');
+                        myData[i] = parseInt('1' + value, 2) - key[i % klen];
+                    } else {
+                        myData[i] = myData[i] - key[i % klen];
+                    }
+                }
+            }
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo("加密解密出错！", ex);
+            throw ex;
+        }
+        return true;
+    }
+
+    static Clone(obj: Message, source: Message): void {
+        for (const key in source) {
+            if (source.hasOwnProperty(key)) {
+                (obj as any)[key] = (source as any)[key];
+            }
+        }
+    }
+
+    static CheckByte(data: Uint8Array): void {
+        if (!data || data.length === 0) return;
+
+        for (let i = 0; i < data.length; i++) {
+            if (data[i] < 128) continue;
+
+            if (i + 1 >= data.length) continue;
+
+            const tmpData = new Uint8Array([data[i], data[i + 1]]);
+            const decoder = new TextDecoder('utf-8');
+            // const tmpStr = PlatformSettings.Encoding.getString(tmpData);//hulei 原始逻辑需要引用到系统system.IO中的getstring()  将字节转换成string
+            const tmpStr = decoder.decode(tmpData);
+            if (this.IsSbc(tmpStr) && !this.IsChinese(tmpStr)) {//判断是否全是全角和中文
+                i++;
+                continue;
+            }
+
+            if (data[i] >= 0x81 && data[i] <= 0xa0) {
+                if (i + 1 >= data.length) continue;
+                if (data[i + 1] < 0x40 || data[i + 1] > 0xfe) {
+                    data[i] = 61;
+                    continue;
+                }
+                i++;
+            } else if (data[i] >= 0xa1 && data[i] <= 0xa9) {
+                if (i + 1 >= data.length) continue;
+                if (data[i + 1] < 0xa1 || data[i + 1] > 0xef) {
+                    data[i] = 61;
+                    continue;
+                }
+                i++;
+            } else if (data[i] >= 0xaa && data[i] <= 0xfe) {
+                if (i + 1 >= data.length) continue;
+                if (data[i + 1] < 0x40) {
+                    data[i] = 61;
+                    continue;
+                } else if (data[i + 1] > 0xa0) {
+                    if (data[i] >= 0xb0 && data[i] <= 0xf7) {
+                        if (data[i + 1] < 0xa1 || data[i + 1] > 0xfe) {
+                            data[i] = 61;
+                            continue;
+                        }
+                    }
+                }
+                i++;
+            } else {
+                data[i] = 61;
+            }
+        }
+    }
+
+    private static IsSbc(str: string): boolean {
+        return str.length * 2 === new TextEncoder().encode(str).length;
+    }
+
+    private static IsChinese(word: string): boolean {
+        if (!word) return false;
+        const rx = /^[\u4e00-\u9fa5]$/;
+        return rx.test(word);
+    }
+}

ant-design-pro-vue3/src/views/front/develop/Communication/Package/MsgXml01.ts

@@ -0,0 +1,140 @@
+// 定义 Message 接口
+interface Message {
+    Fd16: string;
+    Fd96_Q: string;
+    Fd5: string;
+    Fd6: string;
+    Fd2: string;
+    Fd7: string;
+    Fd12: string;
+    FileData: string;
+}
+
+// 模拟 PlatformSettings 类
+class PlatformSettings {
+    static Encoding = {
+        GetBytes: (str: string): Uint8Array => {
+            return new TextEncoder().encode(str);
+        },
+        GetString: (bytes: Uint8Array): string => {
+            return new TextDecoder('gbk').decode(bytes);
+        }
+    };
+}
+
+// 模拟 PlatformLogger 类
+class PlatformLogger {
+    static SystemErrorInfo(message: string, ex: Error) {
+        console.error(`${message}`, ex);
+    }
+
+    static CommunicationInfo(info: string) {
+        console.log(info);
+    }
+}
+
+export class MsgXml01 {
+    private static instance: MsgXml01;
+
+    private constructor() {}
+
+    static GetInstance(): MsgXml01 {
+        if (!this.instance) {
+            this.instance = new MsgXml01();
+        }
+        return this.instance;
+    }
+
+    Integrate(msg: Message): Uint8Array {
+        let totalMsgData: Uint8Array;
+        let dataPartLength: Uint8Array;
+        let dataPart: Uint8Array;
+
+        try {
+            const xmlFirstLine = '<?xml version="1.0" encoding="GBK"?>';
+            const upTagBegin = '<service>';
+            const xmlHeader = this.Msg8583ToHeader(msg);
+            const xmlData = msg.FileData;
+            const upTagEnd = '</service>';
+            const dataPartStr = xmlFirstLine + upTagBegin + xmlHeader + xmlData + upTagEnd;
+
+            dataPart = PlatformSettings.Encoding.GetBytes(dataPartStr);
+            const dataPartLengthInt = dataPart.length;
+            const dataPartLengthStr = dataPartLengthInt.toString().padStart(8, '0');
+            dataPartLength = PlatformSettings.Encoding.GetBytes(dataPartLengthStr);
+
+            totalMsgData = new Uint8Array(8 + dataPartLengthInt);
+            for (let j = 0; j < totalMsgData.length; j++) {
+                if (j < 8) {
+                    totalMsgData[j] = dataPartLength[j];
+                } else {
+                    totalMsgData[j] = dataPart[j - 8];
+                }
+            }
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo('组包发生异常！', ex as Error);
+            throw ex;
+        }
+
+        return totalMsgData;
+    }
+
+    private Msg8583ToHeader(msg: Message): string {
+        let result = '<SysHead>';
+        result += `<Txcode>${msg.Fd16.trim()}</Txcode>`;
+        result += `<FrontTrace>${msg.Fd96_Q.trim()}</FrontTrace>`;
+        result += `<Txdate>${msg.Fd5.trim()}</Txdate>`;
+        result += `<Txtime>${msg.Fd6.trim()}</Txtime>`;
+        result += `<InstNo>${msg.Fd2.trim()}</InstNo>`;
+        result += `<UserNo>${msg.Fd7.trim()}</UserNo>`;
+        result += '</SysHead>';
+        return result;
+    }
+
+    Analyze(msg: Message, data: Uint8Array): boolean {
+        try {
+            this.DoAnalyze(msg, data);
+            return true;
+        } catch (ex) {
+            return false;
+        }
+    }
+
+    DoAnalyze(msg: Message, returnData: Uint8Array): void {
+        try {
+            let xmlDataLen = 0;
+            const tmpLen = returnData.slice(0, 8);
+            xmlDataLen = parseInt(PlatformSettings.Encoding.GetString(tmpLen), 10);
+
+            const ret = returnData.slice(8, 8 + xmlDataLen);
+            const xmlStr = PlatformSettings.Encoding.GetString(ret);
+            PlatformLogger.CommunicationInfo('\n返回报文数据:\n' + xmlStr);
+
+            // 模拟 XML 解析
+            const xmlDoc = this.parseXML(xmlStr);
+            const node = xmlDoc.querySelector('/service/SysHead');
+            if (node) {
+                const childNodes = node.childNodes;
+                msg.Fd16 = childNodes[0].textContent || '';
+                msg.Fd5 = childNodes[1].textContent || '';
+                msg.Fd6 = childNodes[2].textContent || '';
+                msg.Fd2 = childNodes[3].textContent || '';
+                msg.Fd7 = childNodes[4].textContent || '';
+                msg.Fd12 = childNodes[5].textContent || '';
+            }
+
+            const nodeOfBody = xmlDoc.querySelector('/service/Body');
+            if (nodeOfBody) {
+                msg.FileData = nodeOfBody.outerHTML;
+            }
+        } catch (ex) {
+            PlatformLogger.SystemErrorInfo('解析报文失败！', ex as Error);
+            throw ex;
+        }
+    }
+
+    private parseXML(xmlStr: string): Document {
+        const parser = new DOMParser();
+        return parser.parseFromString(xmlStr, 'text/xml');
+    }
+}

ant-design-pro-vue3/src/views/front/develop/Communication/Package/PackageOptions.ts

@@ -0,0 +1,13 @@
+/**
+ * 支持的报文组装方式
+ */
+export enum PackageOptions {
+    /**
+     * 客户端组组解包 
+     */
+    PackageOnClient,
+    /**
+     * 服务端组组解包 
+     */
+    PackageOnServer
+}

ant-design-pro-vue3/src/views/front/develop/Communication/Package/PackageType.ts

@@ -0,0 +1,21 @@
+/**
+ * 支持的报文组装类型
+ */
+export enum PackageType {
+    /**
+     *  使用858301报文
+     */
+    Msg858301,
+    /**
+     *  使用858302报文
+     */
+    Msg858302,
+    /**
+     * 使用858304报文
+     */
+    Msg858304,
+    /**
+     * 反假币xml报文
+     */
+    MsgXml01
+}

ant-design-pro-vue3/src/views/front/develop/Communication/SocketListener/BufferManager.ts

@@ -0,0 +1,104 @@
+export class BufferManager {
+    private m_receiveBuffer: Uint8Array;
+    private m_sendBuffer: Uint8Array;
+
+    private m_maxRequest: number;
+    private m_receiveBufferSize: number;
+    private m_sendBufferSize: number;
+
+    private m_bufferBlockIndex: number;
+    private m_bufferBlockIndexStack: number[];
+
+    private static Locker = {};
+
+    constructor(maxRequest: number, receivevBufferSize: number, sendBufferSize: number) {
+        this.m_maxRequest = maxRequest;
+        this.m_receiveBufferSize = receivevBufferSize;
+        this.m_sendBufferSize = sendBufferSize;
+
+        this.m_bufferBlockIndex = 0;
+        this.m_bufferBlockIndexStack = new Array<number>(maxRequest);
+
+        this.m_receiveBuffer = new Uint8Array(this.m_receiveBufferSize * this.m_maxRequest);
+        this.m_sendBuffer = new Uint8Array(this.m_sendBufferSize * this.m_maxRequest);
+    }
+
+    get ReceiveBufferSize(): number {
+        return this.m_receiveBufferSize;
+    }
+
+    get SendBufferSize(): number {
+        return this.m_sendBufferSize;
+    }
+
+    get ReceiveBuffer(): Uint8Array {
+        return this.m_receiveBuffer;
+    }
+
+    get SendBuffer(): Uint8Array {
+        return this.m_sendBuffer;
+    }
+
+    FreeBufferBlockIndex(bufferBlockIndex: number): void {
+        if (bufferBlockIndex >= this.m_maxRequest || bufferBlockIndex < 0) {
+            return;
+        }
+
+        // 使用 JavaScript 的闭包模拟锁
+        const lock = () => {
+            if (this.m_bufferBlockIndexStack.includes(bufferBlockIndex)) {
+                return;
+            }
+            this.m_bufferBlockIndexStack.push(bufferBlockIndex);
+        };
+        lock();
+    }
+
+    GetBufferBlockIndex(): number {
+        // 使用 JavaScript 的闭包模拟锁
+        const lock = () => {
+            let blockIndex = -1;
+
+            if (this.m_bufferBlockIndexStack.length > 0) {
+                blockIndex = this.m_bufferBlockIndexStack.pop()!;
+            } else {
+                if (this.m_bufferBlockIndex < this.m_maxRequest) {
+                    blockIndex = this.m_bufferBlockIndex++;
+                }
+            }
+
+            return blockIndex;
+        };
+        return lock();
+    }
+
+    GetReceiveBufferOffset(bufferBlockIndex: number): number {
+        if (bufferBlockIndex >= this.m_maxRequest) {
+            throw new Error(`�����������������:${this.m_maxRequest.toString()}`);
+        }
+
+        if (bufferBlockIndex < 0) {
+            return 0;
+        }
+
+        return bufferBlockIndex * this.m_receiveBufferSize;
+    }
+
+    GetSendBufferOffset(bufferBlockIndex: number): number {
+        if (bufferBlockIndex >= this.m_maxRequest) {
+            throw new Error(`�����������������:${this.m_maxRequest.toString()}`);
+        }
+
+        if (bufferBlockIndex < 0) {
+            return 0;
+        }
+
+        return bufferBlockIndex * this.m_sendBufferSize;
+    }
+
+    Clear(): void {
+        this.m_bufferBlockIndexStack = [];
+        this.m_receiveBuffer = new Uint8Array(0);
+        this.m_sendBuffer = new Uint8Array(0);
+    }
+}

ant-design-pro-vue3/src/views/front/develop/Communication/SocketListener/SocketManager.ts

@@ -0,0 +1,393 @@
+// 模拟 BufferManager 类
+import { BufferManager } from './BufferManager';
+
+// 模拟事件处理函数类型
+type EventHandler<T> = (sender: any, args: T) => void;
+
+// 模拟事件参数类
+class ServerPortEventArgs {
+    constructor(public port: number) { }
+}
+
+class DataReceivedEventArgs {
+    constructor(public data: Uint8Array) { }
+}
+
+class DataSendEventArgs {
+    constructor(public sendLength: number) { }
+}
+
+class SocketErrorEventArgs {
+    constructor(public error: Error, public operation: string) { }
+}
+
+// 模拟 Socket 操作枚举
+enum SocketOperation {
+    Bind,
+    Connect,
+    Send
+}
+
+// 模拟 Socket 类
+class Socket {
+    constructor() { }
+    IsBound = false;
+    Close() { }
+    Bind(endPoint: any) { }
+    Listen(backlog: number) { }
+    BeginConnect(endPoint: any, callback: (ar: any) => void, state: any) { }
+    EndConnect(ar: any) { }
+    BeginSend(data: Uint8Array, offset: number, length: number, flags: number, callback: (ar: any) => void, state: any) { }
+    EndSend(ar: any) { return 0; }
+    Connect(endPoint: any) { }
+    Send(data: Uint8Array, offset: number, length: number, flags: number) { return 0; }
+    Shutdown(how: any) { }
+}
+
+// 模拟 ManualResetEvent 类
+class ManualResetEvent {
+    constructor(private initialState: boolean) { }
+    Reset() { }
+    Set() { }
+    WaitOne() { }
+    Close() { }
+}
+
+// 模拟 Func 类型
+type Func<TResult> = () => TResult;
+
+export default class SocketManager {
+    static GetLocalIpAddressList() {
+        return
+    }
+    private m_ListenningSockets: Map<number, Socket> = new Map();
+    private static Locker = {};
+    private m_BufferManager: BufferManager;
+    private m_ThresholdValue = 102400;
+
+    private m_SuspendAllSend = false;
+    private m_StopAllSend = false;
+    private m_MaxListenningRequest: number;
+    private m_SendControl: ManualResetEvent;
+    private m_SendBufferSize: number;
+    private m_ReceiveBufferSize: number;
+    private m_SendTimeOut: number;
+    private m_ReceiveTimeOut: number;
+
+    // 事件
+    public ServerStart: EventHandler<ServerPortEventArgs> | null = null;
+    public ServerStop: EventHandler<ServerPortEventArgs> | null = null;
+    public SendStart: EventHandler | null = null;
+    public SendCompleted: EventHandler | null = null;
+    public DataReceived: EventHandler<DataReceivedEventArgs> | null = null;
+    public Sending: EventHandler<DataSendEventArgs> | null = null;
+    public ErrorHappened: EventHandler<SocketErrorEventArgs> | null = null;
+
+    constructor(maxClientCount = 200, receiveBufferSize = 12400, sendBufferSize = 0, receiveTimeOut = 0, sendTimeOut = 0) {
+        this.m_MaxListenningRequest = maxClientCount;
+        this.m_SendBufferSize = sendBufferSize;
+        this.m_ReceiveBufferSize = receiveBufferSize;
+        this.m_SendTimeOut = sendTimeOut;
+        this.m_ReceiveTimeOut = receiveTimeOut;
+        this.m_BufferManager = new BufferManager(maxClientCount, receiveBufferSize, sendBufferSize);
+        this.m_SendControl = new ManualResetEvent(true);
+    }
+
+    get MaxListenningRequest(): number {
+        return this.m_MaxListenningRequest;
+    }
+
+    get SendBufferSize(): number {
+        return this.m_SendBufferSize;
+    }
+
+    set SendBufferSize(value: number) {
+        this.m_SendBufferSize = value;
+    }
+
+    get ReceiveBufferSize(): number {
+        return this.m_ReceiveBufferSize;
+    }
+
+    set ReceiveBufferSize(value: number) {
+        this.m_ReceiveBufferSize = value;
+    }
+
+    get SendTimeOut(): number {
+        return this.m_SendTimeOut;
+    }
+
+    set SendTimeOut(value: number) {
+        this.m_SendTimeOut = value;
+    }
+
+    get ReceiveTimeOut(): number {
+        return this.m_ReceiveTimeOut;
+    }
+
+    set ReceiveTimeOut(value: number) {
+        this.m_ReceiveTimeOut = value;
+    }
+
+    get ThresholdValue(): number {
+        return this.m_ThresholdValue;
+    }
+
+    get SuspendAllSend(): boolean {
+        return this.m_SuspendAllSend;
+    }
+
+    set SuspendAllSend(value: boolean) {
+        if (value) {
+            this.m_SendControl.Reset();
+        } else {
+            this.m_SendControl.Set();
+        }
+        this.m_SuspendAllSend = value;
+    }
+
+    get StopAllSend(): boolean {
+        return this.m_StopAllSend;
+    }
+
+    set StopAllSend(value: boolean) {
+        if (value && this.SuspendAllSend) {
+            this.SuspendAllSend = false;
+        }
+        this.m_StopAllSend = value;
+    }
+
+    StartListenning(port: number, async = true): boolean {
+        const socket = this.GetSocket(0, 0);
+
+        try {
+            if (!socket.IsBound) {
+                // 模拟锁
+                (() => {
+                    if (!socket.IsBound) {
+                        socket.Bind(this.GetIpv4EndPoint(port));
+                        socket.Listen(this.m_MaxListenningRequest);
+                        this.m_ListenningSockets.set(port, socket);
+                        this.OnServerStart(port);
+                        this.StartReceive(socket, async);
+                    }
+                })();
+            }
+        } catch (se) {
+            socket.Close();
+            this.OnErrorHappened(se as Error, SocketOperation.Bind);
+            return false;
+        }
+
+        return true;
+    }
+
+    StartListenningBatch(ports: number[]): void {
+        ports.forEach(port => {
+            this.StartListenning(port);
+        });
+    }
+
+    StopListenning(onlyCloseSocket: boolean): void {
+        const dic = new Map(this.m_ListenningSockets);
+        this.m_ListenningSockets.clear();
+
+        dic.forEach((socket, port) => {
+            socket.Close();
+            this.OnServerStop(port);
+        });
+
+        if (!onlyCloseSocket) {
+            this.m_BufferManager.Clear();
+            this.m_SendControl.Close();
+        }
+    }
+
+    Send(hostNameOrAddress: string, port: number, data: Uint8Array, async = true): void {
+        if (!data) {
+            throw new Error('�������ݲ���Ϊ��');
+        }
+
+        const endPoint = this.GetIpv4EndPoint(hostNameOrAddress, port);
+        this.Send(endPoint, data, async);
+    }
+
+    Send(endPoint: any, data: Uint8Array, async: boolean): void {
+        if (!data) {
+            throw new Error('�������ݲ���Ϊ��');
+        }
+
+        const socket = this.GetSocket(this.m_SendTimeOut, 0);
+
+        try {
+            this.OnSendStart();
+
+            if (async) {
+                this.SendAsync(socket, endPoint, data);
+            } else {
+                this.SendSynchronize(socket, endPoint, data);
+            }
+        } catch (se) {
+            socket.Close();
+            this.OnErrorHappened(se as Error, SocketOperation.Connect);
+        }
+    }
+
+    SendSynchronize(socket: Socket, endPoint: any, data: Uint8Array): void {
+        socket.Connect(endPoint);
+        this.SendDataInternal(socket, data);
+    }
+
+    SendDataInternal(socket: Socket, data: Uint8Array): void {
+        socket.Send(data, 0, data.length, 0);
+
+        try {
+            socket.Shutdown(0);
+        } catch (ex) { }
+
+        socket.Close();
+        this.FireSendEvents(0);
+    }
+
+    SendAsync(socket: Socket, endPoint: any, data: Uint8Array): void {
+        socket.BeginConnect(endPoint, (ar: any) => {
+            try {
+                socket.EndConnect(ar);
+            } catch (se) {
+                socket.Close();
+                this.OnErrorHappened(se as Error, SocketOperation.Connect);
+                return;
+            }
+
+            this.SendDataInternal(socket, data);
+        }, null);
+    }
+
+    SendWithFunc(hostNameOrAddress: string, port: number, dataGetterFunc: Func<Uint8Array>): void {
+        if (!dataGetterFunc) return;
+
+        const endPoint = this.GetIpv4EndPoint(hostNameOrAddress, port);
+        this.SendEndPointWithFunc(endPoint, dataGetterFunc);
+    }
+
+    SendEndPointWithFunc(endPoint: any, dataGetterFunc: Func<Uint8Array>): void {
+        if (!endPoint) {
+            throw new Error('Զ���ս�㲻��Ϊ��');
+        }
+
+        const sendSocket = this.GetSocket(this.SendTimeOut, 0);
+        this.OnSendStart();
+
+        try {
+            sendSocket.BeginConnect(endPoint, (ar: any) => {
+                try {
+                    sendSocket.EndConnect(ar);
+                } catch (se) {
+                    this.OnErrorHappened(se as Error, SocketOperation.Connect);
+                    sendSocket.Close();
+                    return;
+                }
+
+                const callback = this.GetSendCallback(sendSocket, dataGetterFunc);
+                this.SendDataInternalWithCallback(sendSocket, callback, dataGetterFunc);
+            }, null);
+        } catch (se) {
+            sendSocket.Close();
+            this.OnErrorHappened(se as Error, SocketOperation.Connect);
+        }
+    }
+
+    GetSendCallback(sendSocket: Socket, dataGetterFunc: Func<Uint8Array>): (ar: any) => void {
+        return (receiveResult: any) => {
+            const sendLength = sendSocket.EndSend(receiveResult);
+
+            this.OnSending(sendLength);
+            this.SendDataInternalWithCallback(sendSocket, this.GetSendCallback(sendSocket, dataGetterFunc), dataGetterFunc);
+        };
+    }
+
+    SendDataInternalWithCallback(sendSocket: Socket, callback: (ar: any) => void, dataGetterFunc: Func<Uint8Array>): void {
+        if (this.m_SuspendAllSend) {
+            this.m_SendControl.WaitOne();
+        }
+
+        const data = dataGetterFunc();
+
+        if (this.m_StopAllSend) {
+            sendSocket.Close();
+            return;
+        }
+
+        if (!data || data.length === 0) {
+            this.FireSendEvents(0);
+            sendSocket.Close();
+            return;
+        }
+
+        sendSocket.BeginSend(data, 0, data.length, 0, callback, null);
+    }
+
+    FireSendEvents(socketError: number): void {
+        if (socketError === 0) {
+            this.OnSendCompleted();
+        } else {
+            this.OnErrorHappened(new Error(`Socket error: ${socketError}`), SocketOperation.Send);
+        }
+    }
+
+    StartReceive(listenningSocket: Socket, async: boolean): void {
+        // 由于原代码截断，此处简单实现
+        console.log('Start receiving...');
+    }
+
+    private GetSocket(sendTimeOut: number, receiveTimeOut: number): Socket {
+        return new Socket();
+    }
+
+    private GetIpv4EndPoint(port: number): any;
+    private GetIpv4EndPoint(hostNameOrAddress: string, port: number): any;
+    private GetIpv4EndPoint(arg1: string | number, port?: number): any {
+        // 简单模拟
+        return {};
+    }
+
+    private OnServerStart(port: number): void {
+        if (this.ServerStart) {
+            this.ServerStart(this, new ServerPortEventArgs(port));
+        }
+    }
+
+    private OnServerStop(port: number): void {
+        if (this.ServerStop) {
+            this.ServerStop(this, new ServerPortEventArgs(port));
+        }
+    }
+
+    private OnSendStart(): void {
+        if (this.SendStart) {
+            this.SendStart(this, null);
+        }
+    }
+
+    private OnSendCompleted(): void {
+        if (this.SendCompleted) {
+            this.SendCompleted(this, null);
+        }
+    }
+
+    private OnSending(sendLength: number): void {
+        if (this.Sending) {
+            this.Sending(this, new DataSendEventArgs(sendLength));
+        }
+    }
+
+    private OnErrorHappened(error: Error, operation: SocketOperation): void {
+        if (this.ErrorHappened) {
+            this.ErrorHappened(this, new SocketErrorEventArgs(error, SocketOperation[operation]));
+        }
+    }
+
+    Dispose(): void {
+        this.StopListenning(false);
+    }
+}

ant-design-pro-vue3/src/views/front/develop/ServiceProxy.Ext/ServiceHelper/TradeHandle.ts

@@ -21,6 +21,9 @@ export enum Transit {
 }
 
 export default class TradeHandle {
+    static WriteImportantLog(arg0: string, SerialNumber: any, arg2: string, arg3: string, arg4: string, arg5: any) {
+        //hulei 需要实现该方法
+    }
     /**
      * 获取8583域定义
      */
@@ -69,14 +72,7 @@ export default class TradeHandle {
      * 按照参数指示与外端进行通讯交互
      */
     static async DoTrade(
-        transit: string,
-        integrateData: Uint8Array,
-        kinBrno: string,
-        fileName: string,
-        fileData: Uint8Array,
-        args: any[],
-        serialNo: string
-    ): Promise<Uint8Array[]> {
+        transit: string, integrateData: Uint8Array, kinBrno: string, fileName: string, fileData: Uint8Array, args: any[], serialNo: string, msgType?: string): Promise<Uint8Array[]> {
         const result: Uint8Array[] = []
         try {
             const entity = new TransitEntity()

ant-design-pro-vue3/src/views/front/platfrom/common/RunningParameters/PlatformSettings.ts

@@ -1,4 +1,5 @@
 // 假设 ConfigManager 和 PlatformLogger 已经在其他地方定义
+import PlatformLogger from "@/views/front/platfrom/common/LogSystem/PlatformLogger";
 class ConfigManager {
     private static instance: ConfigManager;
     private constructor() { }
@@ -21,11 +22,6 @@ enum ConfigType {
     System
 }
 
-export default class PlatformLogger {
-    public static SystemErrorInfo(message: string, error: Error): void {
-        console.error(message, error);
-    }
-}
 
 export class PlatformSettings {
     private static _encoding: BufferEncoding;