platfrom serviceproxy

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/CommonFunction.ts

@@ -0,0 +1,127 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+class CommonFunction {
+    static enqualSign = "&&"; // 行分隔符
+    static splitSign = "##"; // 列分隔符
+
+    static ChangeDicToStr(dic: { [key: string]: string }): string {
+        let result = '';
+        if (dic) {
+            let dicstr = '';
+            for (const [key, value] of Object.entries(dic)) {
+                dicstr += `${key}${this.enqualSign}${value}${this.splitSign}`;
+            }
+            if (dicstr.endsWith(this.splitSign)) {
+                result = dicstr.slice(0, -this.splitSign.length);
+            }
+        }
+        return result;
+    }
+
+    static ChangeStrToDic(str: string): { [key: string]: string } | null {
+        const result: { [key: string]: string } = {};
+        if (str) {
+            const tmpstr = str.split(this.splitSign);
+            for (const tmps of tmpstr) {
+                const tmp = tmps.split(this.enqualSign);
+                if (tmp.length !== 2) {
+                    return null;
+                }
+                result[tmp[0]] = tmp[1];
+            }
+        }
+        return result;
+    }
+
+    static ChangStrToArray(str: string): string[] {
+        if (str) {
+            return str.split(this.splitSign);
+        }
+        return [];
+    }
+
+    static ChangArrayToStr(stringarray: string[]): string {
+        let result = '';
+        if (stringarray) {
+            let dicstr = '';
+            for (const tmp of stringarray) {
+                dicstr += `${tmp}${this.splitSign}`;
+            }
+            if (dicstr.endsWith(this.splitSign)) {
+                result = dicstr.slice(0, -this.splitSign.length);
+            }
+        }
+        return result;
+    }
+
+    static ChangeDicToTable(dic: { [key: string]: string }): any[] {
+        const result: any[] = [];
+        if (dic) {
+            for (const [key, value] of Object.entries(dic)) {
+                result.push({ Key: key, Value: value });
+            }
+        }
+        return result;
+    }
+
+    static ChangeTableToDic(table: any[]): { [key: string]: string } | null {
+        const result: { [key: string]: string } = {};
+        if (table) {
+            for (const tmp of table) {
+                const itemArray = Object.values(tmp);
+                if (itemArray.length !== 2) {
+                    return null;
+                }
+                result[itemArray[0].toString()] = itemArray[1].toString();
+            }
+        }
+        return result;
+    }
+
+    static ChangeEntityToTable(entitys: IEntity[]): any[] {
+        const result: any[] = [];
+        if (entitys) {
+            for (const tmpentity of entitys) {
+                if (tmpentity) {
+                    const tmpvalues = tmpentity.ChangeToTable();
+                    if (tmpvalues) {
+                        if (result.length === 0) {
+                            for (let i = 1; i <= tmpvalues.length; i++) {
+                                result.push({});
+                            }
+                        }
+                        for (let i = 0; i < tmpvalues.length; i++) {
+                            result[i][`column${i + 1}`] = tmpvalues[i];
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    static ChangeTableToEntitys<T extends IEntity>(table: any[]): T[] {
+        const result: T[] = [];
+        if (table) {
+            for (const list of table) {
+                const tmp = new (class implements IEntity {
+                    ChangeToTable(): string[] {
+                        throw new Error("Method not implemented.");
+                    }
+                    ChangeFromTable(parms: any[]): void {
+                        throw new Error("Method not implemented.");
+                    }
+                })() as T;
+                tmp.ChangeFromTable(Object.values(list));
+                result.push(tmp);
+            }
+        }
+        return result;
+    }
+}
+
+export default CommonFunction;

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/AttachFile.ts

@@ -0,0 +1,20 @@
+export class AttachFile {
+    /**
+     * 附件在服务方法中做为参数的位置
+     */
+    public AttachIndex: string;
+    /**
+     * 附件类型： 0：Table类型 1：Base基本类型 2：Byte数组类型
+     */
+    public AttachType: string;
+    /**
+     * 附件值
+     */
+    public AttachValue: any;
+
+    constructor(attachIndex: string, attachType: string, attachValue: any) {
+        this.AttachIndex = attachIndex;
+        this.AttachType = attachType;
+        this.AttachValue = attachValue;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/AttchedFiles.ts

@@ -0,0 +1,50 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+// 定义 CommonFunction 类，实现 ChangeDicToStr 和 ChangeStrToDic 方法
+class CommonFunction {
+    static ChangeDicToStr(dic: { [key: string]: string }): string {
+        return Object.entries(dic).map(([key, value]) => `${key}:${value}`).join(',');
+    }
+
+    static ChangeStrToDic(str: string): { [key: string]: string } {
+        return str.split(',').reduce((acc, pair) => {
+            const [key, value] = pair.split(':');
+            if (key && value) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {} as { [key: string]: string });
+    }
+}
+
+export class AttchedFiles implements IEntity {
+    // 附件数据
+    public Filedata: Uint8Array;
+    // 附件信息
+    public Fileinfo: { [key: string]: string };
+    // ID
+    public Id: string;
+    // 记录Filedata长度，做附件传递用，不对外公开
+    public FiledataLength: number;
+
+    constructor() {
+        this.Filedata = new Uint8Array();
+        this.Fileinfo = {};
+        this.Id = '';
+        this.FiledataLength = 0;
+    }
+
+    public ChangeToTable(): string[] {
+        return [this.Id, CommonFunction.ChangeDicToStr(this.Fileinfo), this.Filedata.length.toString()];
+    }
+
+    public ChangeFromTable(parms: any[]): void {
+        this.Id = parms[0].toString();
+        this.Fileinfo = CommonFunction.ChangeStrToDic(parms[1].toString());
+        this.FiledataLength = parseInt(parms[2].toString(), 10);
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/AuthCondInf.ts

@@ -0,0 +1,27 @@
+export class AuthCondInf {
+    Tx_code: string;
+    Seqn: number;
+    Mod: number;
+    Cond: string;
+    Des: string;
+    Uncondflag: number;
+    Funcnum: string;
+
+    constructor(
+        Tx_code: string,
+        Seqn: number,
+        Mod: number,
+        Cond: string,
+        Des: string,
+        Uncondflag: number,
+        Funcnum: string
+    ) {
+        this.Tx_code = Tx_code;
+        this.Seqn = Seqn;
+        this.Mod = Mod;
+        this.Cond = Cond;
+        this.Des = Des;
+        this.Uncondflag = Uncondflag;
+        this.Funcnum = Funcnum;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/AuthResult.ts

@@ -0,0 +1,15 @@
+export class AuthResult {
+    /**
+     * 授权结果
+     */
+    public IsSuccess: boolean;
+    /**
+     * 授权结果提示信息
+     */
+    public Msg: string;
+
+    constructor(isSuccess: boolean, msg: string) {
+        this.IsSuccess = isSuccess;
+        this.Msg = msg;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/IsAuthResult.ts

@@ -0,0 +1,28 @@
+export class IsAuthResult {
+    /**
+     * 授权模式: 
+     * 1、 本地授权
+     * 2、 远程授权
+     * 3、 即可本地又可远程授权
+     */
+    public Mode: number;
+    /**
+     * 授权级别
+     */
+    public Lvl: string;
+    /**
+     * 是否需要授权
+     */
+    public Isauth: boolean;
+    /**
+     * 授权流水
+     */
+    public Records: string;
+
+    constructor(mode: number, lvl: string, isauth: boolean, records: string) {
+        this.Mode = mode;
+        this.Lvl = lvl;
+        this.Isauth = isauth;
+        this.Records = records;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/PFUsedFileInfo.ts

@@ -0,0 +1,45 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+export class PFUsedFileInfo implements IEntity {
+    /**
+     * fileinfo表里的唯一编号
+     */
+    public Id: string;
+
+    /**
+     * 文件在客户端的路径
+     */
+    public FilePath: string;
+
+    /**
+     * 文件名
+     */
+    public FileName: string;
+
+    /**
+     * Md5码
+     */
+    public Md5: string;
+
+    constructor() {
+        this.Id = '';
+        this.FilePath = '';
+        this.FileName = '';
+        this.Md5 = '';
+    }
+
+    public ChangeToTable(): string[] {
+        return [this.Id, this.FilePath, this.FileName, this.Md5];
+    }
+
+    public ChangeFromTable(parms: any[]): void {
+        this.Id = parms[0].toString();
+        this.FilePath = parms[1].toString();
+        this.FileName = parms[2].toString();
+        this.Md5 = parms[3].toString();
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/PicpCheckRecords.ts

@@ -0,0 +1,50 @@
+export interface PicpCheckRecords {
+    /**
+     * 核查流水号
+     */
+    seqNo: string;
+    /**
+     * 流水号
+     */
+    serialNo: string;
+    /**
+     * 报文类型
+     */
+    msgNo: string;
+    /**
+     * 交易号
+     */
+    tradeNo: string;
+    /**
+     * 核查柜员
+     */
+    checkTel: string;
+    /**
+     * 核查机构
+     */
+    checkBrNo: string;
+    /**
+     * 核查方式
+     */
+    checkType: string;
+    /**
+     * 核查日期
+     */
+    checkDate: string;
+    /**
+     * 核查时间
+     */
+    checkTime: string;
+    /**
+     * 核查信息:身份证号,姓名
+     */
+    checkInfoKVs: { [key: string]: any };
+    /**
+     * 核查是否成功
+     */
+    success: string;
+    /**
+     * 备注
+     */
+    comments: string;
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/PicpCheckResInfo.ts

@@ -0,0 +1,74 @@
+export interface PicpCheckResInfo {
+    /**
+     * 返回报文类型
+     */
+    resMsgNo: string;
+    /**
+     * 身份证号
+     */
+    idNo: string;
+    /**
+     * 姓名
+     */
+    name: string;
+    /**
+     * 核查结果
+     */
+    checkResult: string;
+    /**
+     * 签发机构
+     */
+    issue: string;
+    /**
+     * 曾用名
+     */
+    formerName: string;
+    /**
+     * 性别
+     */
+    sex: string;
+    /**
+     * 生日
+     */
+    birthday: string;
+    /**
+     * 出生地
+     */
+    birthPlace: string;
+    /**
+     * 籍贯
+     */
+    nativePlace: string;
+    /**
+     * 文化程度
+     */
+    eduLevel: string;
+    /**
+     * 婚姻状况
+     */
+    marriage: string;
+    /**
+     * 职业
+     */
+    job: string;
+    /**
+     * 服务处所
+     */
+    engageAddr: string;
+    /**
+     * 住址
+     */
+    address: string;
+    /**
+     * 照片64bit压缩编码
+     */
+    photoData: number[];
+    /**
+     * 备注
+     */
+    comments: string;
+    /**
+     * 照片数据长度
+     */
+    photoDataLength: number;
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/ProcessInfo.ts

@@ -0,0 +1,38 @@
+export interface ProcessInfo {
+    /**
+     * 流程实例的唯一标识符
+     */
+    ProcessInstanceId: string;
+    /**
+     * 流水号
+     */
+    SerialNo: string;
+    /**
+     * 流程的创建时间
+     */
+    StartTime: string;
+    /**
+     * 流程的结束时间
+     */
+    EndTime: string;
+    /**
+     * 当前流程节点的相关信息
+     */
+    ActivitiInfo: string;
+    /**
+     * 表示流程的状态，0 代表未结束，1 代表已结束
+     */
+    IsActive: string;
+    /**
+     * 负责办理该流程的柜员
+     */
+    Assignee: string;
+    /**
+     * 流程结束的原因
+     */
+    EndReason: string;
+    /**
+     * 发起该流程的交易号
+     */
+    TradeNo: string;
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/THotKeyMessage.ts

@@ -0,0 +1,47 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+export class THotKeyMessage implements IEntity {
+    public Tellernum: string;
+    public KeyName: string;
+    public KeyDes: string;
+    public KeyState: number;
+    public KeyValue: string;
+    public KeyType: number;
+    public KeyIndex: number;
+
+    constructor() {
+        this.Tellernum = '';
+        this.KeyName = '';
+        this.KeyDes = '';
+        this.KeyState = 0;
+        this.KeyValue = '';
+        this.KeyType = 0;
+        this.KeyIndex = 0;
+    }
+
+    public ChangeToTable(): string[] {
+        return [
+            this.Tellernum,
+            this.KeyName,
+            this.KeyDes,
+            this.KeyState.toString(),
+            this.KeyValue,
+            this.KeyType.toString(),
+            this.KeyIndex.toString()
+        ];
+    }
+
+    public ChangeFromTable(parms: any[]): void {
+        this.Tellernum = parms[0].toString();
+        this.KeyName = parms[1].toString();
+        this.KeyDes = parms[2].toString();
+        this.KeyState = parseInt(parms[3].toString(), 10);
+        this.KeyValue = parms[4].toString();
+        this.KeyType = parseInt(parms[5].toString(), 10);
+        this.KeyIndex = parseInt(parms[6].toString(), 10);
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/TPrintData.ts

@@ -0,0 +1,52 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+export class TPrintData implements IEntity {
+    // 编号
+    public Id: string;
+    // 交易实例号
+    public BusinessId: string;
+    // 表单所属模板号
+    public Formid: string;
+    // 表单所属模板名称
+    public Formname: string;
+    // 表单数据
+    public Formdata: Uint8Array;
+    // 权限次数
+    public Rolecount: number;
+    // 文件长度
+    public FormdataLength: number;
+
+    constructor() {
+        this.Id = '';
+        this.BusinessId = '';
+        this.Formid = '';
+        this.Formname = '';
+        this.Formdata = new Uint8Array();
+        this.Rolecount = 0;
+        this.FormdataLength = 0;
+    }
+
+    public ChangeToTable(): string[] {
+        return [
+            this.Id,
+            this.BusinessId,
+            this.Formid,
+            this.Formname,
+            this.Rolecount.toString(),
+            this.Formdata.length.toString()
+        ];
+    }
+
+    public ChangeFromTable(parms: any[]): void {
+        this.Id = parms[0].toString();
+        this.BusinessId = parms[1].toString();
+        this.Formid = parms[2].toString();
+        this.Formname = parms[3].toString();
+        this.Rolecount = parseInt(parms[4].toString(), 10);
+        this.FormdataLength = parseInt(parms[5].toString(), 10);
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/TTellerHotKey.ts

@@ -0,0 +1,36 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+export class TTellerHotKey implements IEntity {
+    /**
+     * 对应快捷键基础表中的快捷键标识
+     */
+    public KeyName: string;
+    /**
+     * 柜员号
+     */
+    public TellerNum: string;
+    /**
+     * 键值
+     */
+    public KeyValue: string;
+
+    constructor() {
+        this.KeyName = '';
+        this.TellerNum = '';
+        this.KeyValue = '';
+    }
+
+    public ChangeToTable(): string[] {
+        return [this.KeyName, this.TellerNum, this.KeyValue];
+    }
+
+    public ChangeFromTable(parms: any[]): void {
+        this.KeyName = parms[0].toString();
+        this.TellerNum = parms[1].toString();
+        this.KeyValue = parms[2].toString();
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/TellerInfo.ts

@@ -0,0 +1,30 @@
+export interface TellerInfo {
+    /**
+     * 交易号
+     */
+    TradeNo: string;
+    /**
+     * 柜员号
+     */
+    TellerNo: string;
+    /**
+     * 柜员权限
+     */
+    Tlrlvl: string;
+    /**
+     * 机构号
+     */
+    BrNo: string;
+    /**
+     * 交易文件名
+     */
+    TradeFileName: string;
+    /**
+     * 流程状态：0：未完成 ；1:正常完成；2：非正常完成
+     */
+    Status: number;
+    /**
+     * 后台流水号
+     */
+    BlackSerialNo: string;
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/TradeForms.ts

@@ -0,0 +1,61 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+export class TradeForms implements IEntity {
+    /**
+     * 表单模板号
+     */
+    public FormId: string;
+    /**
+     * 表单模板名称
+     */
+    public FormName: string;
+    /**
+     * 权限次数
+     */
+    public RoleCount: number;
+    /**
+     * 是否启用
+     */
+    public IsEnabled: number;
+    /**
+     * 打印排序号
+     */
+    public SortIndex: number;
+    /**
+     * 可授权级别
+     */
+    public AuthLevel: string;
+
+    constructor() {
+        this.FormId = '';
+        this.FormName = '';
+        this.RoleCount = 0;
+        this.IsEnabled = 0;
+        this.SortIndex = 0;
+        this.AuthLevel = '';
+    }
+
+    public ChangeToTable(): string[] {
+        return [
+            this.FormId,
+            this.FormName,
+            this.RoleCount.toString(),
+            this.IsEnabled.toString(),
+            this.SortIndex.toString(),
+            this.AuthLevel
+        ];
+    }
+
+    public ChangeFromTable(parms: any[]): void {
+        this.FormId = parms[0].toString();
+        this.FormName = parms[1].toString();
+        this.RoleCount = parseInt(parms[2].toString(), 10);
+        this.IsEnabled = parseInt(parms[3].toString(), 10);
+        this.SortIndex = parseInt(parms[4].toString(), 10);
+        this.AuthLevel = parms[5].toString();
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/TradeInfo.ts

@@ -0,0 +1,41 @@
+/**
+ * 交易信息类，用于存储交易相关的信息。
+ */
+export class TradeInfo {
+    /**
+     * 交易号
+     */
+    public TxCode: string;
+    /**
+     * 操作员
+     */
+    public Tel: string;
+    /**
+     * 交易机构
+     */
+    public TxBrNo: string;
+    /**
+     * 授权要素信息
+     */
+    public AuthElement: string;
+    /**
+     * 方法序号
+     */
+    public FuncNum: string;
+
+    /**
+     * 构造函数，用于初始化交易信息对象。
+     * @param txCode 交易号
+     * @param tel 操作员
+     * @param txBrNo 交易机构
+     * @param authElement 授权要素信息
+     * @param funcNum 方法序号
+     */
+    constructor(txCode: string, tel: string, txBrNo: string, authElement: string, funcNum: string) {
+        this.TxCode = txCode;
+        this.Tel = tel;
+        this.TxBrNo = txBrNo;
+        this.AuthElement = authElement;
+        this.FuncNum = funcNum;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/TradePrintMessage.ts

@@ -0,0 +1,36 @@
+// 假设 IEntity 接口定义如下
+interface IEntity {
+    ChangeToTable(): string[];
+    ChangeFromTable(parms: any[]): void;
+}
+
+export class TradePrintMessage implements IEntity {
+    /**
+     * 交易号
+     */
+    public TradeNo: string;
+    /**
+     * 交易名称
+     */
+    public TradeName: string;
+    /**
+     * 已有表单数
+     */
+    public FormCount: number;
+
+    constructor() {
+        this.TradeNo = '';
+        this.TradeName = '';
+        this.FormCount = 0;
+    }
+
+    public ChangeToTable(): string[] {
+        return [this.TradeNo, this.TradeName, this.FormCount.toString()];
+    }
+
+    public ChangeFromTable(parms: any[]): void {
+        this.TradeNo = parms[0].toString();
+        this.TradeName = parms[1].toString();
+        this.FormCount = parseInt(parms[2].toString(), 10);
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Entitys/WorkItemDesc.ts

@@ -0,0 +1,42 @@
+export interface WorkItemDesc {
+    /**
+     * 流水号
+     */
+    SerialNo: string;
+    /**
+     * 交易号
+     */
+    TradeNo: string;
+    /**
+     * 流程创建时间
+     */
+    BegTime: string;
+    /**
+     * 完成时间
+     */
+    EndTime: string;
+    /**
+     * 任务描述
+     */
+    TaskDes: string;
+    /**
+     * 工作项Id
+     */
+    WorkItemId: string;
+    /**
+     * 流程Id
+     */
+    ProcessId: string;
+    /**
+     * 数据总线数据
+     */
+    ProcessVariables: { [key: string]: any };
+    /**
+     * 任务变量数据
+     */
+    ItemVariables: { [key: string]: any };
+    /**
+     * 节点名称
+     */
+    NodeName: string;
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Interfaces/IEntity.ts

@@ -0,0 +1,13 @@
+/**
+ * 服务端实体对象接口
+ */
+export interface IEntity {
+    /**
+     * 将服务实体对象向 table 结构转换
+     */
+    ChangeToTable(): string[];
+    /**
+     * 将 table 结构数据向服务实体对象转换
+     */
+    ChangeFromTable(parms: any[]): void;
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Interfaces/ITransitInvoker.ts

@@ -0,0 +1,11 @@
+import { AttachFile } from '../AttachFile';
+import { TransitEntity } from '../TransitEntity';
+
+export interface ITransitInvoker {
+    /**
+     * 向服务端做服务方法通讯
+     * @param transitentity 传输实体
+     * @returns 附件文件列表
+     */
+    commit(transitentity: TransitEntity): Promise<AttachFile[]>;
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/MsgHandle/CryptTools.ts

@@ -0,0 +1,48 @@
+import CryptoJS from 'crypto-js';
+
+// 假设 PlatformSettings 类的定义
+class PlatformSettings {
+    static EncryptsKey: string = 'your_encrypts_key';
+    static Encoding = {
+        GetBytes: (str: string) => CryptoJS.enc.Utf8.parse(str),
+        GetString: (bytes: CryptoJS.lib.WordArray) => CryptoJS.enc.Utf8.stringify(bytes)
+    };
+}
+
+export class CryptTools {
+    // 加密KEY
+    private static KEY = PlatformSettings.EncryptsKey;
+
+    /**
+     * 加密方法
+     * @param msg 明文
+     * @returns 加密后的字节数组
+     */
+    public static DesEncryptFixKey(msg: CryptoJS.lib.WordArray): CryptoJS.lib.WordArray {
+        const byKey = PlatformSettings.Encoding.GetBytes(this.KEY);
+        const IV = CryptoJS.enc.Hex.parse('1234567890ABCDEF');
+        const encrypted = CryptoJS.DES.encrypt(msg, byKey, {
+            iv: IV,
+            mode: CryptoJS.mode.CBC,
+            padding: CryptoJS.pad.Pkcs7
+        });
+        return CryptoJS.enc.Utf8.parse(encrypted.toString());
+    }
+
+    /**
+     * 解密方法
+     * @param msg 需要解密的字节数组
+     * @returns 解密后的字节数组
+     */
+    public static DesDecryptFixKey(msg: CryptoJS.lib.WordArray): CryptoJS.lib.WordArray {
+        const byKey = PlatformSettings.Encoding.GetBytes(this.KEY);
+        const IV = CryptoJS.enc.Hex.parse('1234567890ABCDEF');
+        const encryptedStr = PlatformSettings.Encoding.GetString(msg);
+        const decrypted = CryptoJS.DES.decrypt(encryptedStr, byKey, {
+            iv: IV,
+            mode: CryptoJS.mode.CBC,
+            padding: CryptoJS.pad.Pkcs7
+        });
+        return decrypted;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/MsgHandle/MessageHandle.ts

@@ -0,0 +1,297 @@
+import { EncrypDecryptHelper } from '../../../common/BasicFunctions/BaseClasses/EncrypDecryptHelper'
+
+// 假设 TransitEntity 和 AttachFile 类型定义如下
+interface TransitEntity {
+    ServiceName: string;
+    FuncName: string;
+    Parameters: { [key: string]: string };
+    AttachFiles: AttachFile[];
+}
+
+interface AttachFile {
+    AttachType: string;
+    AttachValue: any;
+    AttachIndex: string;
+}
+
+// 假设 PlatformSettings 和 PlatformLogger 定义如下
+const PlatformSettings = {
+    Encoding: {
+        BodyName: 'utf-8',
+        GetBytes: (str: string) => new TextEncoder().encode(str),
+        GetString: (bytes: Uint8Array) => new TextDecoder().decode(bytes)
+    },
+    IsEncrypt: true
+};
+
+const PlatformLogger = {
+    SystemInfo: (info: string) => console.log(info)
+};
+
+// 假设 Types 定义如下
+const Types = {
+    BaseType: '1',
+    ByteType: '2',
+    TableType: '3'
+};
+
+// 假设 LoginUserInfo 定义如下
+const LoginUserInfo = {
+    TellerNo: '123456'
+};
+
+// 假设 EncrypDecryptHelper 定义如下
+// const EncrypDecryptHelper = {
+//     Encrypt: (data: Uint8Array, flag: boolean) => data, // 简单示例，实际需要实现加密逻辑
+//     Decrypt: (data: Uint8Array, flag: boolean) => data  // 简单示例，实际需要实现解密逻辑
+// };
+
+class MessageHandle {
+    static GroupMessage(transitentity: TransitEntity): Uint8Array {
+        const ms = new Uint8Array(0);
+        const logInfo = new StringBuilder();
+        const xmlMark = `<?xml version="1.0" encoding="${PlatformSettings.Encoding.BodyName}"?>`;
+        let header = '';
+        let data = '';
+        const doc = new DOMParser().parseFromString('<root></root>', 'text/xml');
+
+        logInfo.appendLine();
+        logInfo.appendLine('组包开始:');
+
+        // 数据域
+        const content = doc.createElement('Content');
+        const servicename = doc.createElement('ServiceName');
+        servicename.textContent = transitentity.ServiceName;
+        const methodname = doc.createElement('MethodName');
+        methodname.textContent = transitentity.FuncName;
+        const parameters = doc.createElement('Parameters');
+        logInfo.appendLine(`服务方法：${transitentity.ServiceName}:${transitentity.FuncName}`);
+
+        for (const [key, value] of Object.entries(transitentity.Parameters)) {
+            const parameter = doc.createElement('Parameter');
+            parameter.setAttribute('Index', key);
+            parameter.setAttribute('Value', value);
+            parameters.appendChild(parameter);
+            logInfo.appendLine(`参数：第${key}位参数:${value}`);
+        }
+
+        content.appendChild(servicename);
+        content.appendChild(methodname);
+        content.appendChild(parameters);
+        doc.documentElement.appendChild(content);
+        data = xmlMark + new XMLSerializer().serializeToString(doc.documentElement);
+        const dataByte = PlatformSettings.Encoding.GetBytes(data);
+
+        // 附件
+        let fileByte = new Uint8Array(0);
+        if (transitentity.AttachFiles.length > 0) {
+            const fileMs = new Uint8Array(0);
+            let index = 0;
+            for (const item of transitentity.AttachFiles) {
+                let fileValue = '';
+                let fByte: Uint8Array;
+                let fileType: Uint8Array;
+
+                if (item.AttachType === Types.BaseType) {
+                    fileType = PlatformSettings.Encoding.GetBytes(Types.BaseType);
+                    fByte = PlatformSettings.Encoding.GetBytes(item.AttachValue.toString());
+                } else if (item.AttachType === Types.ByteType) {
+                    fileType = PlatformSettings.Encoding.GetBytes(Types.ByteType);
+                    fByte = item.AttachValue as Uint8Array;
+                } else if (item.AttachType === Types.TableType) {
+                    fileType = PlatformSettings.Encoding.GetBytes(Types.TableType);
+                    const tableDoc = new DOMParser().parseFromString('<Table></Table>', 'text/xml');
+                    const fileTable = item.AttachValue; // 假设是一个合适的表格数据结构
+                    if (fileTable) {
+                        const table = tableDoc.documentElement;
+                        const rowNumber = tableDoc.createElement('RowNumber');
+                        const columnNumber = tableDoc.createElement('ColumnNumber');
+                        rowNumber.textContent = fileTable.length.toString();
+                        columnNumber.textContent = fileTable[0]?.length.toString() || '0';
+                        table.appendChild(rowNumber);
+                        table.appendChild(columnNumber);
+
+                        if (fileTable[0]?.length > 0) {
+                            const columns = tableDoc.createElement('Columns');
+                            table.appendChild(columns);
+                            const fields = tableDoc.createElement('Fields');
+                            columns.appendChild(fields);
+                            for (const column of fileTable[0]) {
+                                const field = tableDoc.createElement('Field');
+                                field.textContent = column;
+                                fields.appendChild(field);
+                            }
+                        }
+
+                        if (fileTable.length > 0) {
+                            const rows = tableDoc.createElement('Rows');
+                            table.appendChild(rows);
+                            for (const list of fileTable) {
+                                const row = tableDoc.createElement('row');
+                                rows.appendChild(row);
+                                const fields = tableDoc.createElement('Fields');
+                                row.appendChild(fields);
+                                for (const fileCell of list) {
+                                    const field = tableDoc.createElement('Field');
+                                    field.textContent = fileCell.toString();
+                                    fields.appendChild(field);
+                                }
+                            }
+                        }
+                    }
+                    fileValue = xmlMark + new XMLSerializer().serializeToString(tableDoc.documentElement);
+                    fByte = PlatformSettings.Encoding.GetBytes(fileValue);
+                }
+
+                const flen = PlatformSettings.Encoding.GetBytes(fByte.length.toString().padStart(8, '0'));
+                const findex = PlatformSettings.Encoding.GetBytes(item.AttachIndex.padStart(2, '0'));
+                const fbak = PlatformSettings.Encoding.GetBytes(''.padStart(19, '0'));
+
+                // 模拟写入操作
+                fileByte = new Uint8Array([...fileByte, ...flen, ...fileType, ...findex, ...fbak, ...fByte]);
+
+                logInfo.appendLine(`第${++index}附件为：${fileValue}`);
+            }
+        }
+
+        // 报文头
+        const dataLen = dataByte.length.toString().padStart(6, '0');
+        const sendType = '0';
+        const branchNo = '000000';
+        const terminalNo = '000000000000';
+        const sendChannel = '0';
+        const encryptType = '0';
+        const fileCnt = transitentity.AttachFiles.length.toString();
+        const terllerNo = LoginUserInfo.TellerNo.padStart(10, ' ');
+        const bak = ''.padStart(26, '0');
+
+        header = dataLen + sendType + branchNo + terminalNo + sendChannel + encryptType + fileCnt + terllerNo + bak;
+        logInfo.appendLine(`64位报文头:${header}`);
+        const headerByte = PlatformSettings.Encoding.GetBytes(header);
+
+        // 报文加密与长度计算
+        let msgByte = new Uint8Array([...headerByte, ...dataByte, ...fileByte]);
+        if (PlatformSettings.IsEncrypt) {
+            msgByte = EncrypDecryptHelper.Encrypt(msgByte, true);
+        }
+        const xmlLenByte = PlatformSettings.Encoding.GetBytes(msgByte.length.toString().padStart(8, '0'));
+        const resultByte = new Uint8Array([...xmlLenByte, ...msgByte]);
+
+        logInfo.appendLine('组包结束');
+        PlatformLogger.SystemInfo(logInfo.toString());
+        return resultByte;
+    }
+
+    static AnalyseMessage(msg: Uint8Array): AttachFile[] | null {
+        let attachfiles: AttachFile[] | null = null;
+        const ms = msg;
+        const logInfo = new StringBuilder();
+
+        if (msg.length === 0) {
+            logInfo.appendLine('解包数据异常');
+            PlatformLogger.SystemInfo(logInfo.toString());
+            return null;
+        }
+
+        const doc = new DOMParser().parseFromString('<root></root>', 'text/xml');
+        logInfo.appendLine();
+        logInfo.appendLine('解包开始');
+
+        // 报文头 验证总长度
+        const lenthByte = ms.slice(0, 8);
+        const xmlLen = parseInt(PlatformSettings.Encoding.GetString(lenthByte), 10);
+        if (xmlLen !== ms.length - 8) {
+            logInfo.appendLine('报文总长度验证失败');
+            PlatformLogger.SystemInfo(logInfo.toString());
+            return null;
+        }
+
+        let message = ms.slice(8);
+        let finalmessage = message;
+        if (PlatformSettings.IsEncrypt) {
+            finalmessage = EncrypDecryptHelper.Decrypt(message, true);
+        }
+
+        const headerByte = finalmessage.slice(0, 64);
+        const header = PlatformSettings.Encoding.GetString(headerByte);
+        logInfo.appendLine(`64位报文头：${header}`);
+
+        const dataLen = parseInt(header.substring(0, 6), 10);
+        const FileCnt = parseInt(header.substring(27, 28), 10);
+
+        // 附件
+        if (FileCnt > 0) {
+            attachfiles = [];
+            let fileByte = finalmessage.slice(64 + dataLen);
+            let fl = 0;
+            for (let i = 0; i < FileCnt; i++) {
+                const attachfile: AttachFile = {
+                    AttachType: '',
+                    AttachValue: null,
+                    AttachIndex: ''
+                };
+                const fhead = PlatformSettings.Encoding.GetString(fileByte.slice(0, 30));
+                const flen = parseInt(fhead.substring(0, 8), 10);
+                const fileValue = fileByte.slice(30, 30 + flen);
+
+                if (fhead.substring(8, 9) === Types.BaseType) {
+                    attachfile.AttachType = Types.BaseType;
+                    attachfile.AttachValue = PlatformSettings.Encoding.GetString(fileValue);
+                } else if (fhead.substring(8, 9) === Types.ByteType) {
+                    attachfile.AttachType = Types.ByteType;
+                    attachfile.AttachValue = fileValue;
+                } else if (fhead.substring(8, 9) === Types.TableType) {
+                    attachfile.AttachType = Types.TableType;
+                    const fileDt = PlatformSettings.Encoding.GetString(fileValue);
+                    const tableDoc = new DOMParser().parseFromString(fileDt, 'text/xml');
+                    logInfo.appendLine(`DataTable附件${i + 1}：${fileDt}`);
+
+                    const table = tableDoc.querySelector('Table');
+                    if (table) {
+                        const dataTable = [];
+                        const columns = table.querySelector('Columns');
+                        if (columns) {
+                            const fields = columns.querySelectorAll('Field');
+                            const columnNames = Array.from(fields).map(field => field.textContent);
+                            dataTable.push(columnNames);
+                        }
+                        const rows = table.querySelector('Rows');
+                        if (rows) {
+                            const rowElements = rows.querySelectorAll('row');
+                            // for (const rowElement of rowElements) {
+                            //     const fields = rowElement.querySelectorAll('Field');
+                            //     const rowData = Array.from(fields).map(field => field.textContent);
+                            //     dataTable.push(rowData);
+                            // }
+                            //TODO报错了待解决
+                        }
+                        attachfile.AttachValue = dataTable;
+                    }
+                }
+
+                fl += flen + 30;
+                fileByte = finalmessage.slice(64 + dataLen + fl);
+                attachfiles.push(attachfile);
+            }
+        }
+
+        logInfo.appendLine('解包结束');
+        PlatformLogger.SystemInfo(logInfo.toString());
+        return attachfiles;
+    }
+}
+
+// 简单的 StringBuilder 实现
+class StringBuilder {
+    private value = '';
+
+    appendLine(line = '') {
+        this.value += line + '\n';
+    }
+
+    toString() {
+        return this.value;
+    }
+}
+
+export default MessageHandle;

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/MsgHandle/SocketTran.ts

@@ -0,0 +1,158 @@
+// 假设 PlatformSettings 是一个全局对象，这里简单模拟
+const PlatformSettings = {
+    ServiceAddress: 'localhost:8080',
+    Timeout: 5000,
+    Encoding: 'utf-8'
+};
+
+// 假设 PlatformLogger 是一个全局对象，这里简单模拟
+const PlatformLogger = {
+    SystemErrorInfo: (message: string, error: Error) => {
+        console.error(`${message} ${error.message}`);
+    }
+};
+
+class SocketTran {
+    private static readonly _transDataLen = 1024;
+    private _mySocket: WebSocket | null = null;
+    private readonly _serviceAddress = PlatformSettings.ServiceAddress;
+    private readonly _timeout = PlatformSettings.Timeout;
+
+    private constructor() {}
+
+    static GetInstance(): SocketTran {
+        return new SocketTran();
+    }
+
+    private async Connect(timeout = 0): Promise<boolean> {
+        try {
+            const [address, portStr] = PlatformSettings.ServiceAddress.split(':');
+            const portArray = portStr.split(',');
+            const port = parseInt(portArray[Math.floor(Math.random() * portArray.length)], 10);
+            const url = `ws://${address}:${port}`;
+
+            return new Promise<boolean>((resolve, reject) => {
+                const socket = new WebSocket(url);
+                this._mySocket = socket;
+
+                const timeoutId = setTimeout(() => {
+                    socket.close();
+                    reject(new Error('Connection timed out'));
+                }, timeout <= 0 ? this._timeout : timeout);
+
+                socket.onopen = () => {
+                    clearTimeout(timeoutId);
+                    resolve(true);
+                };
+
+                socket.onerror = (error) => {
+                    clearTimeout(timeoutId);
+                    PlatformLogger.SystemErrorInfo('Socket连接失败！', error as Error);
+                    resolve(false);
+                };
+            });
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('Socket连接失败！', e as Error);
+            return false;
+        }
+    }
+
+    async Send(msgData: Uint8Array, timeout = 0): Promise<Uint8Array> {
+        for (let i = 0; i < 3; i++) {
+            if (await this.Connect(timeout)) {
+                break;
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+
+        return this.MsgSend(msgData);
+    }
+
+    private async MsgSend(integrateData: Uint8Array): Promise<Uint8Array> {
+        if (!this._mySocket) {
+            throw new Error('Socket is not connected');
+        }
+
+        try {
+            let index = 0;
+            let lastCnt = integrateData.length;
+
+            // 循环发送数据
+            while (lastCnt > 0) {
+                let tmpData: Uint8Array;
+                if (lastCnt > SocketTran._transDataLen) {
+                    tmpData = new Uint8Array(SocketTran._transDataLen);
+                    tmpData.set(integrateData.subarray(index, index + SocketTran._transDataLen));
+                    this._mySocket.send(tmpData);
+                    index += SocketTran._transDataLen;
+                    lastCnt -= SocketTran._transDataLen;
+                } else {
+                    tmpData = new Uint8Array(lastCnt);
+                    tmpData.set(integrateData.subarray(index, index + lastCnt));
+                    this._mySocket.send(tmpData);
+                    lastCnt = 0;
+                }
+            }
+
+            // 接收头部8位数据长度
+            const headByte = await this.receiveBytes(8);
+            const header = new TextDecoder(PlatformSettings.Encoding).decode(headByte);
+            const getDataLength = parseInt(header, 10);
+
+            // 接收数据包
+            const memoryStream = new Uint8Array(getDataLength + 8);
+            memoryStream.set(headByte, 0);
+            let receivedLength = 0;
+
+            while (receivedLength < getDataLength) {
+                const receiveBuffer = await this.receiveBytes(Math.min(getDataLength - receivedLength, SocketTran._transDataLen));
+                memoryStream.set(receiveBuffer, 8 + receivedLength);
+                receivedLength += receiveBuffer.length;
+            }
+
+            this._mySocket.close();
+            return memoryStream;
+        } catch (ex) {
+            if (this._mySocket) {
+                this._mySocket.close();
+            }
+            PlatformLogger.SystemErrorInfo('Socket通讯失败！错误原因：', ex as Error);
+            throw ex;
+        }
+    }
+
+    private receiveBytes(length: number): Promise<Uint8Array> {
+        if (!this._mySocket) {
+            throw new Error('Socket is not connected');
+        }
+
+        return new Promise<Uint8Array>((resolve, reject) => {
+            const buffer = new Uint8Array(length);
+            let receivedLength = 0;
+
+            const onMessage = (event: MessageEvent) => {
+                const data = new Uint8Array(event.data);
+                const remainingLength = length - receivedLength;
+                const copyLength = Math.min(remainingLength, data.length);
+                buffer.set(data.subarray(0, copyLength), receivedLength);
+                receivedLength += copyLength;
+
+                if (receivedLength === length) {
+                    this._mySocket?.removeEventListener('message', onMessage);
+                    resolve(buffer);
+                }
+            };
+
+            const onError = (error: Event) => {
+                this._mySocket?.removeEventListener('message', onMessage);
+                this._mySocket?.removeEventListener('error', onError);
+                reject(error);
+            };
+
+            this._mySocket.addEventListener('message', onMessage);
+            this._mySocket.addEventListener('error', onError);
+        });
+    }
+}
+
+export default SocketTran;

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/ServiceInstance/NettyInvoker.ts

@@ -0,0 +1,73 @@
+// 假设这些类型定义已经存在
+interface TransitEntity {
+    Timeout: number;
+    // 其他可能的属性
+}
+
+interface AttachFile {
+    // 定义 AttachFile 的属性
+}
+
+interface ITransitlnvoker {
+    Commit(transitentity: TransitEntity): Promise<AttachFile[]>;
+}
+
+class MessageHandle {
+    static GroupMessage(transitentity: TransitEntity): Uint8Array | null {
+        // 实现组报文逻辑
+        return null;
+    }
+
+    static AnalyseMessage(reseivemsg: Uint8Array): AttachFile[] | null {
+        // 实现解析报文逻辑
+        return null;
+    }
+}
+
+class SocketTran {
+    private static instance: SocketTran;
+    private constructor() {}
+
+    static GetInstance(): SocketTran {
+        if (!this.instance) {
+            this.instance = new SocketTran();
+        }
+        return this.instance;
+    }
+
+    async Send(sendmsg: Uint8Array, timeout: number): Promise<Uint8Array | null> {
+        // 实现发送报文逻辑
+        return null;
+    }
+}
+
+class PlatformLogger {
+    static SystemErrorInfo(message: string, error: Error): void {
+        console.error(message, error);
+    }
+}
+
+export class NettyInvoker implements ITransitlnvoker {
+    async Commit(transitentity: TransitEntity): Promise<AttachFile[]> {
+        let result: AttachFile[] | null = null;
+        let sendmsg: Uint8Array | null = null;
+        let reseivemsg: Uint8Array | null = null;
+        try {
+            // 组报文
+            sendmsg = MessageHandle.GroupMessage(transitentity);
+            if (sendmsg) {
+                reseivemsg = await SocketTran.GetInstance().Send(sendmsg, transitentity.Timeout);
+                if (reseivemsg) {
+                    // 解析报文
+                    result = MessageHandle.AnalyseMessage(reseivemsg);
+                }
+            }
+        } catch (e) {
+            if (e instanceof Error) {
+                PlatformLogger.SystemErrorInfo("报文通讯异常：", e);
+            }
+            throw new Error("网络通讯失败，请检查网络环境！");
+        }
+        return result || [];
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/ServiceInstance/WebserviceInvoker.ts

@@ -0,0 +1,18 @@
+// 假设这些类型已经在项目中定义
+interface ITransitlnvoker {
+    Commit(transitentity: TransitEntity): AttachFile[];
+}
+
+interface TransitEntity {
+    // 这里可以根据实际情况定义 TransitEntity 的属性
+}
+
+interface AttachFile {
+    // 这里可以根据实际情况定义 AttachFile 的属性
+}
+
+export class WebserviceInvoker implements ITransitlnvoker {
+    public Commit(transitentity: TransitEntity): AttachFile[] {
+        return null;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/ServiceManager.ts

@@ -0,0 +1,102 @@
+// 假设以下接口和类已经定义
+interface ITransitlnvoker {
+    Commit(transitentity: TransitEntity): AttachFile[];
+}
+
+class TransitEntity {
+    ServiceName: string;
+    FuncName: string;
+    Parameters: { [key: string]: string };
+}
+
+class AttachFile {
+    AttachValue: any;
+}
+
+class NettyInvoker implements ITransitlnvoker {
+    Commit(transitentity: TransitEntity): AttachFile[] {
+        // 实现具体逻辑
+        return [];
+    }
+}
+
+class WebserviceInvoker implements ITransitlnvoker {
+    Commit(transitentity: TransitEntity): AttachFile[] {
+        // 实现具体逻辑
+        return [];
+    }
+}
+
+class EncrypDecryptHelper {
+    static Instance: EncrypDecryptHelper = new EncrypDecryptHelper();
+    Mode = {
+        Sm2: 'Sm2'
+    };
+    Init(mode: string, callback: (input: { [key: string]: string }) => { [key: string]: string } | null): boolean {
+        // 实现具体逻辑
+        return true;
+    }
+}
+
+class CommonFunction {
+    static ChangeStrToDic(str: string): { [key: string]: string } {
+        // 实现具体逻辑
+        return {};
+    }
+}
+
+class ServiceManager {
+    private transitlnvoker: ITransitlnvoker;
+    private static instance: ServiceManager;
+
+    public static GetInstance(): ServiceManager {
+        if (!this.instance) {
+            this.instance = new ServiceManager();
+        }
+        return this.instance;
+    }
+
+    private constructor() {
+        this.transitlnvoker = this.GetTransit("netty");
+        const flag = EncrypDecryptHelper.Instance.Init(EncrypDecryptHelper.Instance.Mode.Sm2, (input) => {
+            const entity = new TransitEntity();
+            entity.ServiceName = "UtilService";
+            entity.FuncName = "ExChangeKey";
+            entity.Parameters = { "1": input["ServerRandomRequest"] };
+            const tmpresult = this.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                const tradeReturn = CommonFunction.ChangeStrToDic(tmpresult[0].AttachValue.toString());
+                if (tradeReturn.hasOwnProperty("dataResult") && tradeReturn.hasOwnProperty("KeyHandle")) {
+                    return { "ServerRandom": tradeReturn["dataResult"], "ServerHandle": tradeReturn["KeyHandle"] };
+                }
+            }
+            return null;
+        });
+        if (!flag) {
+            throw new Error("报文通讯加解密初始化异常！");
+        }
+    }
+
+    private GetTransit(transittype: string): ITransitlnvoker {
+        switch (transittype) {
+            case "netty":
+                return new NettyInvoker();
+            case "webservice":
+                return new WebserviceInvoker();
+            default:
+                return new NettyInvoker();
+        }
+    }
+
+    public Commit(transitentity: TransitEntity): AttachFile[] {
+        const func = (entity: TransitEntity) => this.transitlnvoker.Commit(entity);
+        if (!this.CommitWrapper) {
+            return func(transitentity);
+        }
+        return this.CommitWrapper(transitentity, func);
+    }
+
+    public CommitWrapper: ((transitentity: TransitEntity, func: (entity: TransitEntity) => AttachFile[]) => AttachFile[]) | null = null;
+}
+
+export default ServiceManager;

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/TransitEntity.ts

@@ -0,0 +1,22 @@
+// 假设 AttachFile 类的定义如下，实际使用时需要根据具体情况修改
+class AttachFile {
+    // 这里可以添加 AttachFile 类的具体属性和方法
+}
+
+export default class TransitEntity {
+    // 服务方法名
+    public FuncName: string;
+    // 服务类名
+    public ServiceName: string;
+    // 方法参数(以Dictionary方式，key为参数在方法中的位置，value为参数值)
+    public Parameters: { [key: string]: string };
+    // 附件列表，特殊结构(转换成table结构)与大数据byte[]参数做为附件传递
+    public AttachFiles?: AttachFile[];
+    // 超时设置，单位ms
+    public Timeout?: number;
+
+    constructor() {
+        this.Parameters = {};
+        this.AttachFiles = [];
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceFunction/Types.ts

@@ -0,0 +1,15 @@
+// 定义一个 Types 对象，包含三种类型的常量
+export const Types = {
+    /**
+     * 基本类型：String;Int;Boolean等
+     */
+    BaseType: "1",
+    /**
+     * Table类型
+     */
+    TableType: "0",
+    /**
+     * byte数组类型
+     */
+    ByteType: "2"
+};

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/FilesHandle.ts

@@ -0,0 +1,400 @@
+import axios, { AxiosResponse } from 'axios';
+import FileHandle from '../../common/BasicFunctions/Handles/FileHandle'
+
+// 假设这些类型在其他文件中定义
+interface AttchedFiles {
+    Filedata: number[];
+    FiledataLength: number;
+}
+
+interface TransitEntity {
+    ServiceName: string;
+    FuncName: string;
+    Parameters?: { [key: string]: string };
+    AttachFiles?: AttachFile[];
+    Timeout?: number;
+}
+
+interface AttachFile {
+    AttachIndex: string;
+    AttachType: string;
+    AttachValue: any;
+}
+
+interface PFUsedFileInfo {
+    Md5: string;
+    // 其他属性根据实际情况添加
+}
+
+// 假设这些工具函数在其他文件中定义
+class CommonFunction {
+    static ChangeEntityToTable(imageList: AttchedFiles[]): any {
+        // 实现具体逻辑
+        return [];
+    }
+    static ChangStrToArray(str: string): string[] {
+        // 实现具体逻辑
+        return [];
+    }
+    static ChangArrayToStr(arr: string[]): string {
+        // 实现具体逻辑
+        return '';
+    }
+    static ChangeTableToEntitys<T>(table: any): T[] {
+        // 实现具体逻辑
+        return [] as T[];
+    }
+    static ChangeStrToDic(str: string): { [key: string]: string } {
+        // 实现具体逻辑
+        return {};
+    }
+}
+
+class ServiceManager {
+    static async Commit(entity: TransitEntity): Promise<AttachFile[]> {
+        // 模拟请求
+        const response: AxiosResponse<AttachFile[]> = await axios.post('/api/service', entity);
+        return response.data;
+    }
+}
+
+class PlatformLogger {
+    static SystemErrorInfo(message: string, error: Error) {
+        console.error(message, error);
+    }
+}
+
+// class FileHandle {
+//     static GetFileMD5(fileInfo: any): string {
+//         // 实现具体逻辑
+//         return '';
+//     }
+//     static SaveFile(fileInfo: any, data: number[], append: boolean): boolean {
+//         // 实现具体逻辑
+//         return true;
+//     }
+// }
+
+class PlatformSettings {
+    static PagesDirectory: string = 'pages';
+}
+
+export default class FilesHandle {
+    static UpdateAssemblys: { [key: string]: boolean } = {};
+
+    static async PutAttachedFiles(imageList: AttchedFiles[]): Promise<string[]> {
+        let tradeReturn: string[] | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'ProcessService',
+                FuncName: 'PutAttachedFiles',
+                AttachFiles: []
+            };
+
+            const attcheds: AttachFile = {
+                AttachIndex: '1',
+                AttachType: 'TableType',
+                AttachValue: CommonFunction.ChangeEntityToTable(imageList)
+            };
+            entity.AttachFiles.push(attcheds);
+
+            const memoryStream = new Uint8Array();
+            for (const tmp of imageList) {
+                memoryStream.set(tmp.Filedata, memoryStream.length);
+            }
+            const filedata = new Uint8Array(memoryStream.length);
+            filedata.set(memoryStream);
+
+            const attcheds2: AttachFile = {
+                AttachIndex: '2',
+                AttachType: 'ByteType',
+                AttachValue: filedata
+            };
+            entity.AttachFiles.push(attcheds2);
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = CommonFunction.ChangStrToArray(tmpresult[0].AttachValue.toString());
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('PutAttachedFiles方法出现异常：', e as Error);
+            throw e;
+        }
+        return tradeReturn!;
+    }
+
+    static async GetAttachedFiles(fileIDs: string[]): Promise<AttchedFiles[]> {
+        let tradeReturn: AttchedFiles[] | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'ProcessService',
+                FuncName: 'GetAttachedFiles',
+                Parameters: { '1': CommonFunction.ChangArrayToStr(fileIDs) }
+            };
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 2) {
+                tradeReturn = CommonFunction.ChangeTableToEntitys<AttchedFiles>(tmpresult[0].AttachValue as any);
+                if (tradeReturn) {
+                    let i = 0;
+                    for (const tmp of tradeReturn) {
+                        tmp.Filedata = new Array(tmp.FiledataLength);
+                        // tmp.Filedata.set(tmpresult[1].AttachValue.slice(i, i + tmp.FiledataLength));TODO
+                        i += tmp.FiledataLength;
+                    }
+                }
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetAttachedFiles方法出现异常：', e as Error);
+            throw e;
+        }
+        return tradeReturn!;
+    }
+
+    static async CheckMD5(localFilePath: string, serverFilePath: string): Promise<boolean> {
+        let result = false;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'UtilService',
+                FuncName: 'GetFileMD5',
+                Parameters: { '1': serverFilePath }
+            };
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                const serverMd5 = tmpresult[0].AttachValue as string;
+                const fileInfo = new FileHandle();
+                const localMd5 = "";// fileInfo.GetFileMD5(localFilePath);//微软自带的fileInfo TODO
+                result = localMd5.toUpperCase() === serverMd5.toUpperCase();
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetFileMD5方法出现异常：', e as Error);
+            throw e;
+        }
+        return result;
+    }
+
+    static async UpdateTradeDll(actionName: string): Promise<boolean> {
+        if (this.UpdateAssemblys[actionName]) {
+            delete this.UpdateAssemblys[actionName];
+        }
+
+        let result = false;
+        try {
+            const fileName = `${actionName}.dll`;
+            const localFilePath = `${process.cwd()}/${PlatformSettings.PagesDirectory}/${fileName}`;
+
+            const localFile = new FileHandle();
+            if (localFile) {
+                const files = await this.GetUsedFilesInfo(`/${PlatformSettings.PagesDirectory}`, fileName, '1');
+                if (files.length === 1) {
+                    const localMd5 = "";// localFile.GetFileMD5(localFilePath);////微软自带的fileInfo TODO
+                    const serverMd5 = files[0].Md5;
+                    if (localMd5.toUpperCase() === serverMd5.toUpperCase()) {
+                        this.UpdateAssemblys[actionName] = false;
+                        return true;
+                    }
+                } else {
+                    this.UpdateAssemblys[actionName] = false;
+                    return false;
+                }
+            }
+
+            const data = await this.GetDllFile(fileName, `/${PlatformSettings.PagesDirectory}`);
+            if (data) {
+                result = true;// localFile.SaveFile(localFilePath, data, false);//localFile TODO
+                this.UpdateAssemblys[actionName] = true;
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('更新DLL文件UpdateTradeDll方法出现异常：', e as Error);
+        }
+        return result;
+    }
+
+    static async GetDllFile(fileName: string, filePath: string): Promise<number[] | null> {
+        let result: number[] | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'PlatFormService',
+                FuncName: 'GetDllFile',
+                Parameters: { '1': fileName, '2': filePath }
+            };
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = tmpresult[0].AttachValue as number[];
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetDllFile方法出现异常：', e as Error);
+            throw e;
+        }
+        return result;
+    }
+
+    static async GetServerFileNames(serverFilePath: string): Promise<{ [key: string]: string } | null> {
+        let tradeReturn: { [key: string]: string } | null = null;
+        if (!serverFilePath) {
+            throw new Error('参数不能为空');
+        }
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'UtilService',
+                FuncName: 'GetListFileNames',
+                Parameters: { '1': serverFilePath }
+            };
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = CommonFunction.ChangeStrToDic(tmpresult[0].AttachValue.toString());
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetListFileNames方法出现异常：', e as Error);
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    static async SaveFileData(serverFilePath: string, fileData: number[], append: boolean): Promise<boolean> {
+        let tradeReturn = false;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'UtilService',
+                FuncName: 'SaveFile',
+                Parameters: { '1': serverFilePath, '3': append.toString() },
+                AttachFiles: []
+            };
+
+            const file: AttachFile = {
+                AttachIndex: '2',
+                AttachType: 'ByteType',
+                AttachValue: fileData
+            };
+            entity.AttachFiles.push(file);
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = Boolean(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('SaveFile方法出现异常：', e as Error);
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    static async DownloadFile(localFilePath: string, serverFilePath: string): Promise<boolean> {
+        let SaveFileresult;
+        try {
+            if (!serverFilePath || !localFilePath) {
+                throw new Error('参数不能为空');
+            }
+
+            const result = await this.GetFileData(serverFilePath);
+            if (result && result.length > 0) {
+                //const fileHandle = new FileHandle();
+                SaveFileresult = FileHandle.SaveFile(localFilePath, result, false);//类中的GetFileData的将原来的byte转换成额buffer
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('DownloadFile方法出现异常：', e as Error);
+            throw e;
+        }
+        return SaveFileresult;
+    }
+
+    static async GetFileData(serverFilePath: string): Promise<Buffer | null> {
+        const size = 1024 * 50;
+        let tradeReturn: Buffer | null = null;
+        let len = 0;
+        try {
+            len = await this.GetFileBlockLength(serverFilePath);
+
+            if (len <= size) {
+                const entity2: TransitEntity = {
+                    ServiceName: 'UtilService',
+                    FuncName: 'GetFile',
+                    Parameters: { '1': serverFilePath },
+                    Timeout: 10000
+                };
+
+                const tmpresult2 = await ServiceManager.Commit(entity2);
+                if (tmpresult2 && tmpresult2.length === 1) {
+                    tradeReturn = tmpresult2[0].AttachValue as Buffer;
+                }
+            } else {
+                //tradeReturn = new Array(len);
+                let offset = 0;
+                while (offset < len) {
+                    const lens = len - offset > size ? size : len - offset;
+                    const result = await this.GetFileBlock(serverFilePath, offset, lens);
+                    //tradeReturn.set(result, offset);TODO
+                    offset += size;
+                }
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetFile方法出现异常：', e as Error);
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    static async GetUsedFilesInfo(fileName: string, filePath: string, fileType: string): Promise<PFUsedFileInfo[]> {
+        let result: PFUsedFileInfo[] | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'PlatFormService',
+                FuncName: 'GetUsedFilesInfo',
+                Parameters: { '1': fileName, '2': filePath, '3': fileType }
+            };
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = CommonFunction.ChangeTableToEntitys<PFUsedFileInfo>(tmpresult[0].AttachValue as any);
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetUsedFilesInfo方法出现异常：', e as Error);
+            throw e;
+        }
+        return result!;
+    }
+
+    static async GetFileBlock(fileName: string, offset: number, length: number): Promise<number[] | null> {
+        let result: number[] | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'UtilService',
+                FuncName: 'GetFileByLength',
+                Parameters: { '1': fileName, '2': offset.toString(), '3': length.toString() },
+                Timeout: 10000
+            };
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = tmpresult[0].AttachValue as number[];
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetFileByLength方法出现异常：', e as Error);
+            throw e;
+        }
+        return result;
+    }
+
+    static async GetFileBlockLength(fileName: string): Promise<number> {
+        let len = 0;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: 'UtilService',
+                FuncName: 'GetFileLength',
+                Parameters: { '1': fileName }
+            };
+
+            const tmpresult = await ServiceManager.Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                len = Number(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo('GetFileLength方法出现异常：', e as Error);
+            throw e;
+        }
+        return len;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/HotKeysHandle.ts

@@ -0,0 +1,142 @@
+// 假设这些类型定义在其他文件中，这里简单模拟
+interface TransitEntity {
+    ServiceName: string;
+    FuncName: string;
+    Parameters: { [key: string]: string };
+    AttachFiles?: { AttachIndex: string; AttachType: any; AttachValue: any }[];
+}
+
+interface AttachFile {
+    AttachIndex: string;
+    AttachType: any;
+    AttachValue: any;
+}
+
+interface THotKeyMessage {
+    // 这里可以根据实际情况补充属性
+}
+
+interface TTellerHotKey {
+    // 这里可以根据实际情况补充属性
+}
+
+class ServiceManager {
+    private static instance: ServiceManager;
+
+    private constructor() { }
+
+    static GetInstance() {
+        if (!this.instance) {
+            this.instance = new ServiceManager();
+        }
+        return this.instance;
+    }
+
+    Commit(entity: TransitEntity): AttachFile[] {
+        // 这里需要实现实际的提交逻辑
+        return [];
+    }
+}
+
+class CommonFunction {
+    static ChangeTableToEntitys<T>(table: any): T[] {
+        // 这里需要实现实际的转换逻辑
+        return [] as T[];
+    }
+
+    static ChangeEntityToTable(entity: any): any {
+        // 这里需要实现实际的转换逻辑
+        return {};
+    }
+}
+
+class PlatformLogger {
+    static SystemErrorInfo(message: string, error: Error) {
+        console.error(message, error);
+    }
+}
+
+export class HotKeysHandle {
+    static GetKeyByTeller(tellerNum: string): THotKeyMessage[] {
+        let result: THotKeyMessage[] = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "HotKeyService",
+                FuncName: "GetKeyByTeller",
+                Parameters: { "1": tellerNum }
+            };
+            const tmpresult = ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = CommonFunction.ChangeTableToEntitys<THotKeyMessage>(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo("GetKeyByTeller方法出现异常：", e as Error);
+            throw e;
+        }
+        return result;
+    }
+
+    static DelKeyMessage(keyName: string, tellerNum: string): boolean {
+        let result = false;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "HotKeyService",
+                FuncName: "DelKeyMessage",
+                Parameters: { "1": keyName, "2": tellerNum }
+            };
+            const tmpresult = ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = Boolean(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo("DelKeyMessage方法出现异常：", e as Error);
+            throw e;
+        }
+        return result;
+    }
+
+    static DelKeyValue(keyName: string, tellerNum: string, keyValue: string): boolean {
+        let result = false;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "HotKeyService",
+                FuncName: "DelKeyValue",
+                Parameters: { "1": keyName, "2": tellerNum, "3": keyValue }
+            };
+            const tmpresult = ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = Boolean(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo("DelKeyValue方法出现异常：", e as Error);
+            throw e;
+        }
+        return result;
+    }
+
+    static UpdateKeyMessage(tTellerHotkey: TTellerHotKey): boolean {
+        let result = false;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "HotKeyService",
+                FuncName: "UpdateKeyMessage",
+                AttachFiles: [],
+                Parameters: {}
+            };
+            const attach: AttachFile = {
+                AttachIndex: "1",
+                AttachType: "TableType", // 这里假设 TableType 是一个常量或类型
+                AttachValue: CommonFunction.ChangeEntityToTable([tTellerHotkey])
+            };
+            entity.AttachFiles.push(attach);
+            const tmpresult = ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = Boolean(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            PlatformLogger.SystemErrorInfo("UpdateKeyMessage方法出现异常：", e as Error);
+            throw e;
+        }
+        return result;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/InitializeHandle.ts

@@ -0,0 +1,182 @@
+
+import TransitEntity from '../ServiceFunction/TransitEntity';
+import ServiceManager from '../ServiceFunction/ServiceManager';
+import CommonFunction from '../CommonFunction';
+import FilesHandle from '../ServiceHelper/FilesHandle'
+
+//import { CommonParames, TradeParames } from '../../Common/RunningParameters/CommonParames';
+
+// 假设这些类型和方法在其他文件中定义 TODO 
+// interface TransitEntity {
+//     ServiceName: string;
+//     FuncName: string;
+//     Parameters?: { [key: string]: string };
+// }
+
+interface AttachFile {
+    AttachValue: any;
+}
+
+
+// 假设这些全局参数在其他文件中定义
+namespace CommonParames {
+    export let MsgErrorMap: { [key: string]: string };
+    export let Coding: string;
+    export let SysName: string;
+    export let UpdatedClientPath: string;
+    export let TradeInfoPath: string;
+    export let ConfigFilePath: string;
+    export let TempFilePath: string;
+    export let TellerSysHelp: string;
+}
+
+namespace TradeParames {
+    export let MsgFormat: { [key: string]: { [key: string]: any } };
+}
+
+export class InitializeHandle {
+    static async InitMsgFormat() {
+        if (!TradeParames.MsgFormat) {
+            // TradeParames.MsgFormat = await this.GetMessageFormatMap();//TODO
+        }
+    }
+
+    static async InitErrorMap() {
+        if (!CommonParames.MsgErrorMap) {
+            CommonParames.MsgErrorMap = await this.GetErrorMap();
+        }
+    }
+
+    static async InitConfig() {
+        try {
+            let result: string | null = null;
+            const entity: TransitEntity = {
+                ServiceName: "CommonService",
+                FuncName: "GetClientConfig",
+                Parameters: {},
+                AttachFiles: null,
+                Timeout: 10000
+            };
+            const tmpresult = ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = tmpresult[0].AttachValue as string;
+            }
+
+            const dict = CommonFunction.ChangeStrToDic(result);
+            // 初始化配置文件
+            CommonParames.Coding = dict["CharacterSet"];
+            CommonParames.SysName = dict["MsgTitle"];
+            CommonParames.UpdatedClientPath = dict["UpdatedClientPath"];
+            CommonParames.TradeInfoPath = dict["TradeInfoPath"];
+            CommonParames.ConfigFilePath = dict["ConfigFilePath"];
+            CommonParames.TempFilePath = dict["TempFilePath"];
+            CommonParames.TellerSysHelp = dict["TellerSysHelp"];
+        } catch (e) {
+            throw e;
+        }
+        return true;
+    }
+
+    static async GetFdItemMap() {
+        const table: { [key: string]: string }[] = [];
+        const entity: TransitEntity = {
+            ServiceName: "TradeService",
+            FuncName: "GetFdItemMap",
+            Parameters: {},
+            AttachFiles: null,
+            Timeout: 10000
+        };
+        const tmpresult = ServiceManager.GetInstance().Commit(entity);
+        let data: string | null = null;
+        if (tmpresult && tmpresult.length === 1) {
+            data = tmpresult[0].AttachValue as string;
+        }
+        if (data) {
+            const lines = data.split('\n');
+            for (const line of lines) {
+                if (line) {
+                    const rows = line.split('|');
+                    const item = {
+                        Code: rows[0],
+                        Type: rows[1],
+                        Length: rows[2],
+                        DotLength: rows[3],
+                        Description: rows[4],
+                        FieldType: rows[5],
+                        MaxLength: rows[6],
+                        DataName: rows[7]
+                    };
+                    table.push(item);
+                }
+            }
+        }
+        return table;
+    }
+
+    static async GetMessageFormatMap() {
+        // const messageFormatMap: { [key in Transit]: { [key: string]: any } } = {} as any;
+        // const transits = Object.values(Transit);
+        // for (const transit of transits) {
+        //    const dictionary = await this.GetTradeMessageFormat(transit.toString());
+        //    if (dictionary && Object.keys(dictionary).length > 0) {
+        //        messageFormatMap[transit as Transit] = dictionary;
+        //    }
+        //  }
+        return "";
+    }
+
+    static async GetTradeMessageFormat(transitName: string) {
+        let dictionary: { [key: string]: any } | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "TradeService",
+                FuncName: "GetTradeMessageFormat",
+                Parameters: { "1": transitName },
+                AttachFiles: null,
+                Timeout: 10000
+            };
+            const tmpresult = ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                dictionary = CommonFunction.ChangeStrToDic(tmpresult[0].AttachValue.toString());
+            }
+        } catch (e) {
+            throw e;
+        }
+        return dictionary;
+    }
+
+    static async GetErrorMap() {
+        // TODO: 暂时先这样处理，考虑移动到更新管理中去
+        const localPath = `${process.cwd()}/errorMap.xml`;
+        const serverPath = `${CommonParames.ConfigFilePath}errorMap.xml`;
+        const fs = require('fs').promises;
+        const isFileValid = await FilesHandle.CheckMD5(localPath, serverPath);
+        if (!fs.existsSync(localPath) || !isFileValid) {
+            // 更新文件
+            if (fs.existsSync(localPath)) {
+                await fs.unlink(localPath);
+            }
+            const data = await FilesHandle.GetFileData(serverPath);
+            await fs.writeFile(localPath, Buffer.from(data));
+        }
+        // 读取配置文件
+        const dictionary: { [key: string]: string } = {};
+        const xml = await fs.readFile(localPath, 'utf-8');
+        const DOMParser = require('xmldom').DOMParser;
+        const document = new DOMParser().parseFromString(xml, 'text/xml');
+        const root = document.documentElement;
+        if (root) {
+            for (let i = 0; i < root.childNodes.length; i++) {
+                const node = root.childNodes[i];
+                if (node.nodeName === "error") {
+                    const name = node.attributes.getNamedItem("name")?.value;
+                    const value = node.attributes.getNamedItem("value")?.value;
+                    if (name && value) {
+                        dictionary[name] = value;
+                    }
+                }
+            }
+        }
+        return dictionary;
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/PicpHandle.ts

@@ -0,0 +1,107 @@
+//TODO此代码没用
+
+// // 假设这些类型定义在其他文件中，需要根据实际情况导入
+// //import { AttachFile, PicpCheckRecords, PicpCheckResInfo, Types } from './your-entity-types';
+
+// import TransitEntity from '../ServiceFunction/TransitEntity';
+// import ServiceManager from '../ServiceFunction/ServiceManager';
+// import CommonFunction from '../CommonFunction';
+// import FilesHandle from '../ServiceHelper/FilesHandle'
+// export class PicpHandle {
+//     public static async PicpCommonRequest(msgStr: string): Promise<Uint8Array | null> {
+//         let tradeReturn: Uint8Array | null = null;
+//         try {
+//             const entity: TransitEntity = {
+//                 ServiceName: "PicpService",
+//                 FuncName: "PicpCommonRequest",
+//                 Parameters: { "1": msgStr }
+//             };
+//             const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 tradeReturn = tmpresult[0].AttachValue as Uint8Array;
+//             }
+//         } catch (e) {
+//             throw e;
+//         }
+//         return tradeReturn;
+//     }
+
+//     public static async PicpCheckRequest(picpCheckRecords: PicpCheckRecords): Promise<PicpCheckResInfo | null> {
+//         let tradeReturn: PicpCheckResInfo | null = null;
+//         try {
+//             const entity: TransitEntity = {
+//                 ServiceName: "PicpService",
+//                 FuncName: "PicpCheckRequest",
+//                 Parameters: {},
+//                 AttachFiles: []
+//             };
+//             const attcheds: AttachFile = {
+//                 AttachIndex: "1",
+//                 AttachType: Types.TableType,
+//                 //  AttachValue: CommonFunction.ChangeEntityTable<PicpCheckRecords[], any>([picpCheckRecords])
+//             };
+//             entity.AttachFiles.push(attcheds);
+//             const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 //tradeReturn = CommonFunction.ChangeEntityTable<any, PicpCheckResInfo>(tmpresult[0].AttachValue as any);
+//                 if (tradeReturn) {
+//                     tradeReturn.photoData = tmpresult[1].AttachValue as Uint8Array;
+//                 }
+//             }
+//         } catch (e) {
+//             throw e;
+//         }
+//         return tradeReturn;
+//     }
+
+//     public static async GenCheckReqMessage(picpCheckRecords: PicpCheckRecords): Promise<string | null> {
+//         let tradeReturn: string | null = null;
+//         try {
+//             const entity: TransitEntity = {
+//                 ServiceName: "PicpService",
+//                 FuncName: "GenCheckReqMessage",
+//                 AttachFiles: []
+//             };
+//             const attcheds: AttachFile = {
+//                 AttachIndex: "1",
+//                 AttachType: Types.TableType,
+//                 AttachValue: CommonFunction.ChangeEntityTable<PicpCheckRecords[], any>([picpCheckRecords])
+//             };
+//             entity.AttachFiles.push(attcheds);
+//             const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 tradeReturn = tmpresult[0].AttachValue.toString();
+//             }
+//         } catch (e) {
+//             throw e;
+//         }
+//         return tradeReturn;
+//     }
+
+//     public static async AnalyzeCheckResMessage(recvData: Uint8Array): Promise<PicpCheckResInfo | null> {
+//         let tradeReturn: PicpCheckResInfo | null = null;
+//         try {
+//             const entity: TransitEntity = {
+//                 ServiceName: "PicpService",
+//                 FuncName: "AnalyzeCheckResMessage",
+//                 AttachFiles: []
+//             };
+//             const attcheds2: AttachFile = {
+//                 AttachIndex: "1",
+//                 AttachType: Types.ByteType,
+//                 AttachValue: recvData
+//             };
+//             entity.AttachFiles.push(attcheds2);
+//             const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 tradeReturn = CommonFunction.ChangeEntityTable<any, PicpCheckResInfo>(tmpresult[0].AttachValue as any);
+//                 if (tradeReturn) {
+//                     tradeReturn.photoData = tmpresult[1].AttachValue as Uint8Array;
+//                 }
+//             }
+//         } catch (e) {
+//             throw e;
+//         }
+//         return tradeReturn;
+//     }
+// }

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/PrintHandle.ts

@@ -0,0 +1,228 @@
+import axios from 'axios';
+
+// 假设这些类型定义在其他文件中
+interface TransitEntity {
+  ServiceName: string;
+  FuncName: string;
+  Parameters: { [key: string]: string };
+  AttachFiles: AttachFile[];
+}
+
+interface AttachFile {
+  AttachIndex: string;
+  AttachType: string;
+  AttachValue: any;
+}
+
+interface TradeForms {}
+interface TradePrintMessage {}
+interface TPrintData {
+  Formdata: any;
+  FormdataLength: number;
+}
+
+// 假设 ServiceManager 类的 Commit 方法对应一个 HTTP 请求
+const ServiceManager = {
+  GetInstance: () => ({
+    Commit: async (entity: TransitEntity) => {
+      try {
+        const response = await axios.post('/api/print-service', entity);
+        return response.data;
+      } catch (error) {
+        throw error;
+      }
+    },
+  }),
+};
+
+// 假设 CommonFunction 类的方法已经实现
+class CommonFunction {
+  static ChangeEntityToTable(entity: any) {
+    // 实现实体到 DataTable 的转换逻辑
+    return null;
+  }
+
+  static ChangeTableToEntitys<T>(table: any): T[] {
+    // 实现 DataTable 到实体数组的转换逻辑
+    return [];
+  }
+}
+
+// 假设 PlatformLogger 类的方法已经实现
+class PlatformLogger {
+  static SystemErrorInfo(message: string, error: any) {
+    console.error(message, error);
+  }
+}
+
+export class PrintHandle {
+  static async AddTradeForm(tradeid: string, tradeform: TradeForms[]): Promise<boolean> {
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'PrintService',
+        FuncName: 'AddTradeForm',
+        Parameters: { '1': tradeid },
+        AttachFiles: [],
+      };
+
+      const data: AttachFile = {
+        AttachIndex: '2',
+        AttachType: 'TableType',
+        AttachValue: CommonFunction.ChangeEntityToTable(tradeform),
+      };
+      entity.AttachFiles.push(data);
+
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        return Boolean(tmpresult[0].AttachValue);
+      }
+      return false;
+    } catch (e) {
+      PlatformLogger.SystemErrorInfo('AddTradeForm方法出现异常：', e);
+      throw e;
+    }
+  }
+
+  static async GetTradePrintMessage(tradeno: string, tradename: string): Promise<TradePrintMessage[]> {
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'PrintService',
+        FuncName: 'GetTradePrintMessage',
+        Parameters: { '1': tradeno, '2': tradename },
+        AttachFiles: [],
+      };
+
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        return CommonFunction.ChangeTableToEntitys<TradePrintMessage>(tmpresult[0].AttachValue);
+      }
+      return [];
+    } catch (e) {
+      PlatformLogger.SystemErrorInfo('GetTradePrintMessage方法出现异常：', e);
+      throw e;
+    }
+  }
+
+  static async GetTradeFormsByTradecode(tradecode: string): Promise<TradeForms[]> {
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'PrintService',
+        FuncName: 'GetTradeFormsByTradecode',
+        Parameters: { '1': tradecode },
+        AttachFiles: [],
+      };
+
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        return CommonFunction.ChangeTableToEntitys<TradeForms>(tmpresult[0].AttachValue);
+      }
+      return [];
+    } catch (e) {
+      PlatformLogger.SystemErrorInfo('GetTradeFormsByTradecode方法出现异常：', e);
+      throw e;
+    }
+  }
+
+  static async AddPrintData(printdata: TPrintData): Promise<string> {
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'PrintService',
+        FuncName: 'AddPrintData',
+        Parameters: {},
+        AttachFiles: [],
+      };
+
+      const attcheds: AttachFile = {
+        AttachIndex: '1',
+        AttachType: 'TableType',
+        AttachValue: CommonFunction.ChangeEntityToTable([printdata]),
+      };
+      entity.AttachFiles.push(attcheds);
+
+      const attcheds2: AttachFile = {
+        AttachIndex: '2',
+        AttachType: 'ByteType',
+        AttachValue: printdata.Formdata,
+      };
+      entity.AttachFiles.push(attcheds2);
+
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        return tmpresult[0].AttachValue as string;
+      }
+      return null;
+    } catch (e) {
+      PlatformLogger.SystemErrorInfo('AddPrintData方法出现异常：', e);
+      throw e;
+    }
+  }
+
+  static async GetPrintDataByBusinessId(businessId: string): Promise<TPrintData[]> {
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'PrintService',
+        FuncName: 'GetPrintDataByBusinessId',
+        Parameters: { '1': businessId },
+        AttachFiles: [],
+      };
+
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 2) {
+        const result = CommonFunction.ChangeTableToEntitys<TPrintData>(tmpresult[0].AttachValue);
+        let i = 0;
+        if (result) {
+          result.forEach((tmp) => {
+            tmp.Formdata = new Uint8Array(tmp.FormdataLength);
+            tmp.Formdata.set(tmpresult[1].AttachValue.slice(i, i + tmp.FormdataLength));
+            i += tmp.FormdataLength;
+          });
+        }
+        return result;
+      }
+      return [];
+    } catch (e) {
+      PlatformLogger.SystemErrorInfo('GetPrintDataByBusinessId方法出现异常：', e);
+      throw e;
+    }
+  }
+
+  static async GetFormPrintedCount(id: string): Promise<number> {
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'PrintService',
+        FuncName: 'GetFormPrintedCount',
+        Parameters: { '1': id },
+        AttachFiles: [],
+      };
+
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        return Number(tmpresult[0].AttachValue);
+      }
+      return 0;
+    } catch (e) {
+      PlatformLogger.SystemErrorInfo('GetFormPrintedCount方法出现异常：', e);
+      throw e;
+    }
+  }
+
+  static async AddPrintHistory(pdid: string, worker: string, author: string): Promise<boolean> {
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'PrintService',
+        FuncName: 'AddPrintHistory',
+        Parameters: { '1': pdid, '2': worker, '3': author },
+        AttachFiles: [],
+      };
+
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        return Boolean(tmpresult[0].AttachValue);
+      }
+      return false;
+    } catch (e) {
+      PlatformLogger.SystemErrorInfo('AddPrintHistory方法出现异常：', e);
+      throw e;
+    }
+  }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/TradeHandle.ts

@@ -0,0 +1,373 @@
+import axios from 'axios';
+
+// 假设这些类型在其他文件中定义
+type Transit = string;
+type AttachFile = {
+  AttachIndex: string;
+  AttachType: string;
+  AttachValue: any;
+};
+type TransitEntity = {
+  ServiceName: string;
+  FuncName: string;
+  Parameters: { [key: string]: string };
+  AttachFiles: AttachFile[];
+};
+type TradeInfo = any;
+type IsAuthResult = any;
+type AuthResult = any;
+type AuthCondInf = any;
+
+// 假设 ServiceManager 封装了 HTTP 请求逻辑
+class ServiceManager {
+  private static instance: ServiceManager;
+
+  private constructor() {}
+
+  public static GetInstance(): ServiceManager {
+    if (!this.instance) {
+      this.instance = new ServiceManager();
+    }
+    return this.instance;
+  }
+
+  public async Commit(entity: TransitEntity): Promise<AttachFile[]> {
+    try {
+      const response = await axios.post('/api/service', entity);
+      return response.data as AttachFile[];
+    } catch (error) {
+      throw error;
+    }
+  }
+}
+
+// 假设这些常量和函数在其他文件中定义
+const CommonParames = {
+  TempFilePath: '',
+  Coding: 'utf-8'
+};
+const FilesHandle = {
+  GetFileData: async (filePath: string): Promise<Uint8Array> => {
+    try {
+      const response = await axios.get(filePath, { responseType: 'arraybuffer' });
+      return new Uint8Array(response.data);
+    } catch (error) {
+      throw error;
+    }
+  }
+};
+const CommonFunction = {
+  ChangeEntityTable: <TIn, TOut>(input: TIn): TOut => {
+    // 这里需要根据实际逻辑实现转换
+    return {} as TOut;
+  },
+  ChangStrToArray: (str: string): string[] => {
+    return str.split(',');
+  }
+};
+
+export class TradeHandle {
+  public static async DoTrade(
+    transit: Transit,
+    integrateData: Uint8Array,
+    kinBrno: string,
+    fileName: string,
+    fileFlag: boolean,
+    args: any[]
+  ): Promise<Uint8Array | null> {
+    let result: Uint8Array | null = null;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'DoTradeByTransit',
+        Parameters: {
+          '1': transit.toString(),
+          '3': kinBrno,
+          '4': fileName,
+          '5': fileFlag.toString(),
+          '6': ''
+        },
+        AttachFiles: []
+      };
+      const data: AttachFile = {
+        AttachIndex: '2',
+        AttachType: 'ByteType',
+        AttachValue: integrateData
+      };
+      entity.AttachFiles.push(data);
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = tmpresult[0].AttachValue as Uint8Array;
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async GetTradeFile(fileName: string): Promise<Uint8Array | null> {
+    const filePath = CommonParames.TempFilePath + fileName + 'dhcc';
+    try {
+      return await FilesHandle.GetFileData(filePath);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async ClearvFile(fileName: string): Promise<boolean> {
+    const vfileName = CommonParames.TempFilePath + fileName;
+    let result = false;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'UtilService',
+        FuncName: 'SaveFile',
+        Parameters: {
+          '1': fileName,
+          '3': false.toString()
+        },
+        AttachFiles: []
+      };
+      const data: AttachFile = {
+        AttachIndex: '2',
+        AttachType: 'ByteType',
+        AttachValue: new Uint8Array()
+      };
+      entity.AttachFiles.push(data);
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = Boolean(tmpresult[0].AttachValue);
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async Addvfile(fileName: string, fileContent: string): Promise<boolean> {
+    const vfileName = CommonParames.TempFilePath + fileName;
+    const data = new TextEncoder().encode(fileContent);
+    let result = false;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'UtilService',
+        FuncName: 'SaveFile',
+        Parameters: {
+          '1': vfileName,
+          '3': true.toString()
+        },
+        AttachFiles: []
+      };
+      const attachdata: AttachFile = {
+        AttachIndex: '2',
+        AttachType: 'ByteType',
+        AttachValue: data
+      };
+      entity.AttachFiles.push(attachdata);
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = Boolean(tmpresult[0].AttachValue);
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async CheckAuth(inf: TradeInfo): Promise<IsAuthResult | null> {
+    let result: IsAuthResult | null = null;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'CheckAuth',
+        Parameters: {},
+        AttachFiles: []
+      };
+      const data: AttachFile = {
+        AttachIndex: '1',
+        AttachType: 'TableType',
+        AttachValue: CommonFunction.ChangeEntityTable<TradeInfo[], any>([inf])
+      };
+      entity.AttachFiles.push(data);
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        const rmpresult = CommonFunction.ChangeEntityTable<any, IsAuthResult[]>(
+          tmpresult[0].AttachValue as any
+        );
+        result = rmpresult[0];
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async DoAuthByAuthno(authno: string): Promise<AuthResult | null> {
+    let result: AuthResult | null = null;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'DoAuthByAuthno',
+        Parameters: {
+          '1': authno
+        },
+        AttachFiles: []
+      };
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        const rmpresult = CommonFunction.ChangeEntityTable<any, AuthResult[]>(
+          tmpresult[0].AttachValue as any
+        );
+        result = rmpresult[0];
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async DoAuthByAuth(
+    auth: string,
+    pwd: string,
+    lvl: string | null,
+    records: string
+  ): Promise<AuthResult | null> {
+    let result: AuthResult | null = null;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'DoAuthByAuth',
+        Parameters: {
+          '1': auth,
+          '2': pwd,
+          '3': lvl || '',
+          '4': records
+        },
+        AttachFiles: []
+      };
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        const rmpresult = CommonFunction.ChangeEntityTable<any, AuthResult[]>(
+          tmpresult[0].AttachValue as any
+        );
+        result = rmpresult[0];
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async CheckAuthBytxno(txno: string): Promise<number> {
+    let result = 0;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'CheckAuthBytxno',
+        Parameters: {
+          '1': txno
+        },
+        AttachFiles: []
+      };
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = Number(tmpresult[0].AttachValue);
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async Getuserlvl(txno: string): Promise<string | null> {
+    let result: string | null = null;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'Getuserlvl',
+        Parameters: {
+          '1': txno
+        },
+        AttachFiles: []
+      };
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = tmpresult[0].AttachValue as string;
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async AddAuthCond(
+    txcode: string,
+    authcondinf: AuthCondInf[]
+  ): Promise<boolean> {
+    let result = false;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'AddAuthCond',
+        Parameters: {
+          '1': txcode
+        },
+        AttachFiles: []
+      };
+      const data: AttachFile = {
+        AttachIndex: '2',
+        AttachType: 'TableType',
+        AttachValue: CommonFunction.ChangeEntityTable<AuthCondInf[], any>(authcondinf)
+      };
+      entity.AttachFiles.push(data);
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = Boolean(tmpresult[0].AttachValue);
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async GetAuthCondByTradecode(txcode: string): Promise<AuthCondInf[] | null> {
+    let result: AuthCondInf[] | null = null;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'GetAuthCondByTradecode',
+        Parameters: {
+          '1': txcode
+        },
+        AttachFiles: []
+      };
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = CommonFunction.ChangeEntityTable<any, AuthCondInf[]>(
+          tmpresult[0].AttachValue as any
+        );
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+
+  public static async GetAuthLvls(): Promise<string[] | null> {
+    let result: string[] | null = null;
+    try {
+      const entity: TransitEntity = {
+        ServiceName: 'TradeService',
+        FuncName: 'GetAuthLvls',
+        Parameters: {},
+        AttachFiles: []
+      };
+      const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+      if (tmpresult && tmpresult.length === 1) {
+        result = CommonFunction.ChangStrToArray(tmpresult[0].AttachValue as string);
+      }
+    } catch (error) {
+      throw error;
+    }
+    return result;
+  }
+}

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/UserManagerHandle.ts

@@ -0,0 +1,321 @@
+// import { ServiceManager } from './ServiceManager'; // 假设 ServiceManager 已经在项目中定义
+// import { TransitEntity, AttachFile } from './TransitEntity'; // 假设 TransitEntity 和 AttachFile 已经在项目中定义
+// import { CommonFunction } from './CommonFunction'; // 假设 CommonFunction 已经在项目中定义
+// import { THotKeyMessage, TTellerHotKey } from './Entitys'; // 假设 THotKeyMessage 和 TTellerHotKey 已经在项目中定义
+// import { CommonParames } from './CommonParames'; // 假设 CommonParames 已经在项目中定义
+
+// export class UserManagerHandle {
+//     // 快捷键管理模块
+//     public static async GetKeyByTeller(tellerNum: string): Promise<THotKeyMessage[] | null> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'HotKeyService';
+//             entity.FuncName = 'GetKeyByTeller';
+//             entity.Parameters = { '1': tellerNum };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return CommonFunction.ChangeEntityTable<DataTable, THotKeyMessage[]>((tmpresult[0].AttachValue as DataTable));
+//             }
+//             return null;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async DelKeyMessage(keyName: string, tellerNum: string): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'HotKeyService';
+//             entity.FuncName = 'DelKeyMessage';
+//             entity.Parameters = { '1': keyName, '2': tellerNum };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async DelKeyValue(keyName: string, tellerNum: string, keyValue: string): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'HotKeyService';
+//             entity.FuncName = 'DelKeyValue';
+//             entity.Parameters = { '1': keyName, '2': tellerNum, '3': keyValue };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async UpdateKeyMessage(tTellerHotkey: TTellerHotKey): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'HotKeyService';
+//             entity.FuncName = 'UpdateKeyMessage';
+//             const attach = new AttachFile();
+//             attach.AttachIndex = '1';
+//             attach.AttachType = 'TableType';
+//             const tmp = [tTellerHotkey];
+//             attach.AttachValue = CommonFunction.ChangeEntityTable<TTellerHotKey[], DataTable>(tmp);
+//             entity.AttachFiles.push(attach);
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     // 柜员管理模块
+//     public static async SendMessage(key: string, sender: string, time: string, title: string): Promise<void> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'SocketSendMessage';
+//             entity.Parameters = { '1': key, '2': sender, '3': time, '4': title };
+//             await ServiceManager.getInstance().Commit(entity);
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async SendMessage(sender: string, message: string, TradeNo: string[]): Promise<void> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'SendMessage';
+//             entity.Parameters = { '1': sender, '2': message, '3': CommonFunction.ChangArrayToStr(TradeNo) };
+//             await ServiceManager.getInstance().Commit(entity);
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async GetOutOfData(tradeno: string, tradetype: string, key_words: string, branch_no: string): Promise<string | null> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'TradeService';
+//             entity.FuncName = 'GetOutOfData';
+//             entity.Parameters = { '1': tradeno, '2': tradetype, '3': key_words, '4': branch_no };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return tmpresult[0].AttachValue as string;
+//             }
+//             return null;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async SetOutOfData(guid: string, tradenum: string, tradetype: string, keywords: string, tradedata: string, tellerno: string, branch_no: string): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'TradeService';
+//             entity.FuncName = 'SetOutOfData';
+//             entity.Parameters = { '1': guid, '2': tradenum, '3': tradetype, '4': keywords, '5': tradedata, '6': tellerno, '7': branch_no };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async UpdateOutOfData(Guid: string, tradedata: string): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'TradeService';
+//             entity.FuncName = 'UpdateOutOfData';
+//             entity.Parameters = { '1': Guid, '2': tradedata };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async InsertBlob(tableName: string, columnName: string, strWhere: string, data: Uint8Array): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'InsertBlob';
+//             entity.Parameters = { '1': tableName, '2': columnName, '3': strWhere };
+//             const files = new AttachFile();
+//             files.AttachIndex = '4';
+//             files.AttachType = 'ByteType';
+//             files.AttachValue = data;
+//             entity.AttachFiles.push(files);
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async DeleteFolderOrFile(sPath: string): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'DeleteFolder';
+//             entity.Parameters = { '1': sPath };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async GetBlob(tableName: string, columnName: string, strWhere: string): Promise<Uint8Array | null> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'GetBlobColumn';
+//             entity.Parameters = { '1': tableName, '2': columnName, '3': strWhere };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return tmpresult[0].AttachValue as Uint8Array;
+//             }
+//             return null;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async SaveConfFile(fileName: string, file: Uint8Array, flag: boolean): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'SaveFile';
+//             entity.Parameters = { '1': CommonParames.ConfigFilePath + fileName, '3': flag.toString() };
+//             const files = new AttachFile();
+//             files.AttachIndex = '2';
+//             files.AttachType = 'ByteType';
+//             files.AttachValue = file;
+//             entity.AttachFiles.push(files);
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async findReportFile(path: string): Promise<string[] | null> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'FindReportFile';
+//             entity.Parameters = { '1': path };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return CommonFunction.ChangStrToArray(tmpresult[0].AttachValue as string);
+//             }
+//             return null;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async GetConfFile(fileName: string): Promise<Uint8Array | null> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'GetFile';
+//             entity.Parameters = { '1': CommonParames.ConfigFilePath + fileName };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return tmpresult[0].AttachValue as Uint8Array;
+//             }
+//             return null;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async ExecuteSql(strsql: string): Promise<number> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'ExecuteSql';
+//             entity.Parameters = { '1': strsql };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Number(tmpresult[0].AttachValue);
+//             }
+//             return 0;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async ExecuteQuery(sql: string): Promise<string[] | null> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'ExecuteQuery';
+//             entity.Parameters = { '1': sql };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return CommonFunction.ChangStrToArray(tmpresult[0].AttachValue as string);
+//             }
+//             return null;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async ExecuteSQLTran(SQLStringList: string[]): Promise<boolean> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'ExecuteSQLTran';
+//             entity.Parameters = { '1': CommonFunction.ChangArrayToStr(SQLStringList) };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return Boolean(tmpresult[0].AttachValue);
+//             }
+//             return false;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+
+//     public static async SortSockAddress(Address: string[]): Promise<string | null> {
+//         try {
+//             const entity = new TransitEntity();
+//             entity.ServiceName = 'UtilService';
+//             entity.FuncName = 'SortSockAddress';
+//             entity.Parameters = { '1': CommonFunction.ChangArrayToStr(Address) };
+//             const tmpresult = await ServiceManager.getInstance().Commit(entity);
+//             if (tmpresult && tmpresult.length === 1) {
+//                 return tmpresult[0].AttachValue as string;
+//             }
+//             return null;
+//         } catch (e) {
+//             throw e;
+//         }
+//     }
+// }
+//TODO此代码没用

ant-design-pro-vue3/src/views/front/platfrom/serviceproxy/ServiceHelper/WorkFlowHandle.ts

@@ -0,0 +1,331 @@
+// 假设以下类型和类的定义
+interface TransitEntity {
+    ServiceName: string;
+    FuncName: string;
+    Parameters: { [key: string]: string };
+    AttachFiles?: AttachFile[];
+}
+
+interface AttachFile {
+    AttachIndex: string;
+    AttachType: any;
+    AttachValue: any;
+}
+
+interface TellerInfo {
+    // 假设 TellerInfo 有具体的属性
+}
+
+interface WorkItemDesc {
+    // 假设 WorkItemDesc 有具体的属性
+}
+
+interface ProcessInfo {
+    // 假设 ProcessInfo 有具体的属性
+}
+
+class ServiceManager {
+    private static instance: ServiceManager;
+    private constructor() {}
+
+    public static GetInstance(): ServiceManager {
+        if (!this.instance) {
+            this.instance = new ServiceManager();
+        }
+        return this.instance;
+    }
+
+    public async Commit(entity: TransitEntity): Promise<AttachFile[]> {
+        // 这里需要实现具体的提交逻辑，例如发送 HTTP 请求
+        return [];
+    }
+}
+
+class CommonFunction {
+    static ChangeDicToStr(dic: { [key: string]: any }): string {
+        return JSON.stringify(dic);
+    }
+
+    static ChangeStrToDic(str: string): { [key: string]: any } {
+        return JSON.parse(str);
+    }
+
+    static ChangeEntityTable<TInput, TOutput>(input: TInput): TOutput {
+        // 这里需要实现具体的转换逻辑
+        return {} as TOutput;
+    }
+}
+
+export class WorkFlowHandle {
+    public static async GetWorkFlowTradeReturn(workflowId: string): Promise<string | null> {
+        let tradeReturn: string | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "TradeRequest",
+                Parameters: { "1": workflowId }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = tmpresult[0].AttachValue as string;
+            }
+        } catch (e) {
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    public static async GetWorkFlowTradeSubmit(
+        tellerinfo: TellerInfo,
+        tradePageData: Uint8Array,
+        alldatas: { [key: string]: object },
+        id: string,
+        serialNo: string,
+        isWorkFlow: boolean,
+        firstNodeFlag: boolean
+    ): Promise<string | null> {
+        let tradeReturn: string | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "TradeSubmit",
+                Parameters: {
+                    "3": CommonFunction.ChangeDicToStr(alldatas),
+                    "4": id,
+                    "5": serialNo,
+                    "6": isWorkFlow.toString(),
+                    "7": firstNodeFlag.toString()
+                },
+                AttachFiles: []
+            };
+
+            const teller: AttachFile = {
+                AttachIndex: "1",
+                AttachType: null, // 需要根据实际情况设置
+                AttachValue: CommonFunction.ChangeEntityTable<TellerInfo[], any>([tellerinfo])
+            };
+            entity.AttachFiles.push(teller);
+
+            const pagedata: AttachFile = {
+                AttachIndex: "2",
+                AttachType: null, // 需要根据实际情况设置
+                AttachValue: tradePageData
+            };
+            entity.AttachFiles.push(pagedata);
+
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = tmpresult[0].AttachValue as string;
+            }
+        } catch (e) {
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    public static async GetWorkFlowWorkItem(tellerNo: string, state: string): Promise<WorkItemDesc[] | null> {
+        let tradeReturn: WorkItemDesc[] | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "GetWorkItems",
+                Parameters: { "1": tellerNo, "2": state } // 原代码参数键重复，修正为不同键
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = CommonFunction.ChangeEntityTable<any, WorkItemDesc[]>(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    public static async ProcessSuspend(processid: string): Promise<string | null> {
+        let tradeReturn: string | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "ProcessSuspend",
+                Parameters: { "1": processid }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = tmpresult[0].AttachValue as string;
+            }
+        } catch (e) {
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    public static async ProcessResume(processid: string): Promise<string | null> {
+        let tradeReturn: string | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "ProcessResume",
+                Parameters: { "1": processid }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = tmpresult[0].AttachValue as string;
+            }
+        } catch (e) {
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    public static async ProcessDelete(processid: string): Promise<string | null> {
+        let tradeReturn: string | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "ProcessDelete",
+                Parameters: { "1": processid }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                tradeReturn = tmpresult[0].AttachValue as string;
+            }
+        } catch (e) {
+            throw e;
+        }
+        return tradeReturn;
+    }
+
+    public static async GetTradePageData(serialNo: string, ActiviteName: string): Promise<Uint8Array | null> {
+        let result: Uint8Array | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "GetTradePageData",
+                Parameters: { "1": serialNo, "2": ActiviteName }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = tmpresult[0].AttachValue as Uint8Array;
+            }
+        } catch (e) {
+            throw e;
+        }
+        return result;
+    }
+
+    public static async GetTradedataBySerialNo(serialNo: string): Promise<{ [key: string]: object } | null> {
+        let result: { [key: string]: object } | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "GetTradedataBySerialNo",
+                Parameters: { "1": serialNo }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = CommonFunction.ChangeStrToDic(tmpresult[0].AttachValue.toString());
+            }
+        } catch (e) {
+            throw e;
+        }
+        return result;
+    }
+
+    public static async getProcessInfosByUserId(userId: string): Promise<ProcessInfo[] | null> {
+        let result: ProcessInfo[] | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "GetProcessInfosByUserId",
+                Parameters: { "1": userId }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = CommonFunction.ChangeEntityTable<any, ProcessInfo[]>(tmpresult[0].AttachValue);
+            }
+        } catch (e) {
+            throw e;
+        }
+        return result;
+    }
+
+    public static async deleteProcessInsById(proInsId: string, delReason: string): Promise<void> {
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "DeleteProcessInsById",
+                Parameters: { "1": proInsId, "2": delReason }
+            };
+            await ServiceManager.GetInstance().Commit(entity);
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    public static async deleteHisTaskInsByuserId(TellerNo: string): Promise<void> {
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "DeleteHisTaskInsByuserId",
+                Parameters: { "1": TellerNo }
+            };
+            await ServiceManager.GetInstance().Commit(entity);
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    public static async deleteHisProcessInsByuserId(TellerNo: string): Promise<void> {
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "DeleteHisProcessInsByuserId",
+                Parameters: { "1": TellerNo }
+            };
+            await ServiceManager.GetInstance().Commit(entity);
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    public static async GiveUpTask(taskid: string): Promise<void> {
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "GiveUpTask",
+                Parameters: { "1": taskid }
+            };
+            await ServiceManager.GetInstance().Commit(entity);
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    public static async GenNextSerialNo(
+        tradeNo: string,
+        telNo: string,
+        brNo: string,
+        isWorkFlow: boolean
+    ): Promise<string | null> {
+        let result: string | null = null;
+        try {
+            const entity: TransitEntity = {
+                ServiceName: "ProcessService",
+                FuncName: "GenNextSerialNo",
+                Parameters: {
+                    "1": tradeNo,
+                    "2": telNo,
+                    "3": brNo,
+                    "4": isWorkFlow.toString()
+                }
+            };
+            const tmpresult = await ServiceManager.GetInstance().Commit(entity);
+            if (tmpresult && tmpresult.length === 1) {
+                result = tmpresult[0].AttachValue as string;
+            }
+        } catch (e) {
+            throw e;
+        }
+        return result;
+    }
+}