develop communication转写提交

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

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Platform.Common.RunningParameters;
+
+namespace TellerSystem.Communication
+{
+    public class CommonSettings
+    {
+        #region
+        /// <summary>
+        /// 通讯采用的加密方式
+        /// </summary>
+        public static string KeyStr
+        {
+            get
+            {
+                return ConfigManager.GetInstance().GetConfigValue("KeyStr", ConfigType.System);
+            }
+        }
+        #endregion
+    }
+}

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

@@ -0,0 +1,242 @@
+import { ref, reactive } from 'vue'
+import { PlatformSettings } from './PlatformSettings'
+import { PlatformLogger } from './PlatformLogger'
+import { BitMapInstance } from './BitMapInstance'
+
+/**
+ * 报文通讯域定义，交易调用
+ */
+export class Message {
+    // 交易附件数据
+    private _fileData = ref<string>('')
+    private _filename = ref<string>('')
+    private _fdDict = reactive<Record<string, Uint8Array>>({})
+    private _BigFds_: Record<string, any> = {}
+
+    /**
+     * 交易文件附件传送标志
+     */
+    get fileFlag(): boolean {
+        return this._fileData.value !== ''
+    }
+    set fileFlag(value: boolean) {
+        if (!value) this._fileData.value = ''
+    }
+
+    /**
+     * 传入的文件名
+     */
+    get filename(): string {
+        return this._filename.value
+    }
+    set filename(value: string) {
+        this._filename.value = value
+    }
+
+    /**
+     * 交易文件附件数据
+     */
+    get fileData(): string {
+        return this._fileData.value
+    }
+    set fileData(value: string) {
+        this._fileData.value = value
+    }
+
+    /**
+     * 获取Fd域值
+     */
+    public getFdVaule(fdName: string): any {
+        let result = ''
+        if (this._fdDict[fdName]) {
+            const decoder = new TextDecoder()
+            result = BitMapInstance.FdBitMap[fdName].RealValue(decoder.decode(this._fdDict[fdName]))
+        }
+        return result
+    }
+
+    /**
+     * 获取参数指定域的组包数据
+     */
+    internal getFdFormatValue(fdName: string): string {
+        let result = ''
+        if (this._fdDict[fdName]) {
+            const decoder = new TextDecoder()
+            result = decoder.decode(this._fdDict[fdName])
+        }
+        return result
+    }
+
+    /**
+     * 设置Fd域值
+     */
+    public setFdValue(fdName: string, value: any): void {
+        this.setFdFormatValue(fdName, value)
+        if (!fdName.endsWith('0')) {
+            const bigFdName = `${fdName.substring(0, 3)}0`
+            const fds = BitMapInstance.FdBitMap[bigFdName]
+            delete this._BigFds_[fds.Code]
+            
+            for (const fd of fds.Children) {
+                if (fd.Code === fdName) break
+                if (!this._fdDict[fd.Code]) {
+                    this.setFdFormatValue(fd.Code, null)
+                }
+            }
+        }
+    }
+
+    /**
+     * 根据域类型格式化输入数据
+     */
+    private setFdFormatValue(fdName: string, value: any): void {
+        if (BitMapInstance.FdBitMap[fdName]) {
+            const item = BitMapInstance.FdBitMap[fdName]
+            const encoder = new TextEncoder()
+            const formatValue = encoder.encode(item.FormatValue(value))
+            
+            this._fdDict[fdName] = formatValue
+        }
+    }
+
+    // 以下是各域的定义，保持与C#代码相同的命名规范
+    get Fd1(): string { return this.getFdVaule('0010').toString() }
+    set Fd1(value: string) { this.setFdValue('0010', value) }
+
+    get Fd2(): string { return this.getFdVaule('0020').toString() }
+    set Fd2(value: string) { this.setFdValue('0020', value) }
+
+    get Fd3(): string { return this.getFdVaule('0030').toString() }
+    set Fd3(value: string) { this.setFdValue('0030', value) }
+
+    get Fd4(): string { return this.getFdVaule('0040').toString() }
+    set Fd4(value: string) { this.setFdValue('0040', value) }
+
+    get Fd5(): string { return this.getFdVaule('0050').toString() }
+    set Fd5(value: string) { this.setFdValue('0050', value) }
+
+    get Fd6(): string { return this.getFdVaule('0060').toString() }
+    set Fd6(value: string) { this.setFdValue('0060', value) }
+
+    get Fd7(): string { return this.getFdVaule('0070').toString() }
+    set Fd7(value: string) { this.setFdValue('0070', value) }
+
+    get Fd8(): string { return this.getFdVaule('0080').toString() }
+    set Fd8(value: string) { this.setFdValue('0080', value) }
+
+    get Fd9_1(): string { return this.getFdVaule('0091').toString() }
+    set Fd9_1(value: string) { this.setFdValue('0091', value) }
+
+    get Fd9_2(): string { return this.getFdVaule('0092').toString() }
+    set Fd9_2(value: string) { this.setFdValue('0092', value) }
+
+    get Fd9_3(): string { return this.getFdVaule('0093').toString() }
+    set Fd9_3(value: string) { this.setFdValue('0093', value) }
+
+    get Fd9_4(): string { return this.getFdVaule('0094').toString() }
+    set Fd9_4(value: string) { this.setFdValue('0094', value) }
+
+    get Fd10(): string { return this.getFdVaule('0100').toString() }
+    set Fd10(value: string) { this.setFdValue('0100', value) }
+
+    // 继续实现其他域...
+    get Fd11(): string { return this.getFdVaule('0110').toString() }
+    set Fd11(value: string) { this.setFdValue('0110', value) }
+
+    get Fd12(): string { return this.getFdVaule('0120').toString() }
+    set Fd12(value: string) { this.setFdValue('0120', value) }
+
+    get Fd13(): string { return this.getFdVaule('0130').toString() }
+    set Fd13(value: string) { this.setFdValue('0130', value) }
+
+    get Fd14(): string { return this.getFdVaule('0140').toString() }
+    set Fd14(value: string) { this.setFdValue('0140', value) }
+
+    get Fd15_1(): string { return this.getFdVaule('0151').toString() }
+    set Fd15_1(value: string) { this.setFdValue('0151', value) }
+
+    get Fd15_2(): string { return this.getFdVaule('0152').toString() }
+    set Fd15_2(value: string) { this.setFdValue('0152', value) }
+
+    get Fd15_3(): string { return this.getFdVaule('0153').toString() }
+    set Fd15_3(value: string) { this.setFdValue('0153', value) }
+
+    get Fd15_4(): string { return this.getFdVaule('0154').toString() }
+    set Fd15_4(value: string) { this.setFdValue('0154', value) }
+
+    get Fd15_5(): string { return this.getFdVaule('0155').toString() }
+    set Fd15_5(value: string) { this.setFdValue('0155', value) }
+
+    get Fd15_6(): string { return this.getFdVaule('0156').toString() }
+    set Fd15_6(value: string) { this.setFdValue('0156', value) }
+
+    get Fd15_7(): string { return this.getFdVaule('0157').toString() }
+    set Fd15_7(value: string) { this.setFdValue('0157', value) }
+
+    get Fd15_8(): string { return this.getFdVaule('0158').toString() }
+    set Fd15_8(value: string) { this.setFdValue('0158', value) }
+
+    get Fd15_9(): string { return this.getFdVaule('0159').toString() }
+    set Fd15_9(value: string) { this.setFdValue('0159', value) }
+
+    get Fd15_A(): string { return this.getFdVaule('015A').toString() }
+    set Fd15_A(value: string) { this.setFdValue('015A', value) }
+
+    get Fd15_B(): string { return this.getFdVaule('015B').toString() }
+    set Fd15_B(value: string) { this.setFdValue('015B', value) }
+
+    get Fd15_C(): string { return this.getFdVaule('015C').toString() }
+    set Fd15_C(value: string) { this.setFdValue('015C', value) }
+
+    get Fd15_D(): string { return this.getFdVaule('015D').toString() }
+    set Fd15_D(value: string) { this.setFdValue('015D', value) }
+
+    get Fd15_E(): string { return this.getFdVaule('015E').toString() }
+    set Fd15_E(value: string) { this.setFdValue('015E', value) }
+
+    get Fd15_F(): string { return this.getFdVaule('015F').toString() }
+    set Fd15_F(value: string) { this.setFdValue('015F', value) }
+
+    get Fd15_G(): string { return this.getFdVaule('015G').toString() }
+    set Fd15_G(value: string) { this.setFdValue('015G', value) }
+
+    get Fd15_H(): string { return this.getFdVaule('015H').toString() }
+    set Fd15_H(value: string) { this.setFdValue('015H', value) }
+
+    get Fd15_I(): string { return this.getFdVaule('015I').toString() }
+    set Fd15_I(value: string) { this.setFdValue('015I', value) }
+
+    get Fd15_J(): string { return this.getFdVaule('015J').toString() }
+    set Fd15_J(value: string) { this.setFdValue('015J', value) }
+
+    // 继续实现剩余域...
+    get Fd16(): string { return this.getFdVaule('0160').toString() }
+    set Fd16(value: string) { this.setFdValue('0160', value) }
+
+    get Fd17(): string { return this.getFdVaule('0170').toString() }
+    set Fd17(value: string) { this.setFdValue('0170', value) }
+
+    get Fd18(): string { return this.getFdVaule('0180').toString() }
+    set Fd18(value: string) { this.setFdValue('0180', value) }
+
+    get Fd19_1(): string { return this.getFdVaule('0191').toString() }
+    set Fd19_1(value: string) { this.setFdValue('0191', value) }
+
+    get Fd19_2(): string { return this.getFdVaule('0192').toString() }
+    set Fd19_2(value: string) { this.setFdValue('0192', value) }
+
+    get Fd19_3(): string { return this.getFdVaule('0193').toString() }
+    set Fd19_3(value: string) { this.setFdValue('0193', value) }
+
+    get Fd19_4(): string { return this.getFdVaule('0194').toString() }
+    set Fd19_4(value: string) { this.setFdValue('0194', value) }
+
+    get Fd19_5(): string { return this.getFdVaule('0195').toString() }
+    set Fd19_5(value: string) { this.setFdValue('0195', value) }
+
+    get Fd20(): string { return this.getFdVaule('0200').toString() }
+    set Fd20(value: string) { this.setFdValue('0200', value) }
+
+    // 实现剩余所有域...
+    // 按照相同模式实现Fd21到Fd47的所有域
+}

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

@@ -0,0 +1,114 @@
+import { Message } from './Message'
+import { PackageType } from './PackageType'
+import { TransitType } from './TransitType'
+import { MsgPackage } from './MsgPackage'
+import { BitMapInstance } from './BitMapInstance'
+import { PlatformSettings } from './PlatformSettings'
+import { PlatformLogger } from './PlatformLogger'
+
+/**
+ * Message的扩展方法集合
+ */
+export class MessageExtension {
+    /**
+     * 执行通讯操作
+     */
+    public static doTransit(message: Message): boolean {
+        let packageType = PackageType.Msg858301
+        switch (message.TransitNode) {
+            case TransitType.CallServer:
+                packageType = PackageType.Msg858302
+                break
+            case TransitType.CallNoFileSys:
+                packageType = PackageType.MsgXml01
+                break
+            default:
+                break
+        }
+        
+        if (message.CustomizeTransitEntry) {
+            return message.CustomizeTransitEntry.process(message, packageType)
+        }
+        return MessageExtension.doTransitInternal(message, packageType)
+    }
+
+    /**
+     * 执行通讯操作(内部方法)
+     */
+    private static doTransitInternal(message: Message, packageType: PackageType): boolean {
+        return MsgPackage.trade(message, packageType, message.TransitName)
+    }
+
+    /**
+     * Message对象域信息序列化，用于授权操作
+     */
+    public static serializeForAuth(message: Message): string {
+        const ret: Record<string, string> = {}
+        const empty: string[] = []
+        
+        for (const fd of Object.values(BitMapInstance.FdBitMap)) {
+            const type = fd.getItemType()
+            const key = fd.Code
+            const value = message.getFdVaule(fd.Code).toString()
+
+            let typeSuffix = ''
+            if (type === String) {
+                typeSuffix = '_0'
+            } else if (type === Number) {
+                typeSuffix = '_1'
+            } else {
+                throw new Error(`不支持的域类型，请检查定义！->${fd.Code}`)
+            }
+
+            if (!value.trim()) {
+                empty.push(key + typeSuffix)
+            } else {
+                ret[key + typeSuffix] = value
+            }
+        }
+
+        if (empty.length > 0) {
+            ret['empty'] = empty.join(',')
+        }
+
+        return JSON.stringify(ret)
+    }
+
+    /**
+     * 获取报文位图类型信息
+     */
+    public static getMsgBitMapTypes(message: Message): Record<string, string> {
+        const result: Record<string, string> = {}
+        
+        for (const item of Object.values(BitMapInstance.FdBitMap)) {
+            const type = item.getItemType()
+            const value = type === String ? '1' : '0'
+            result[`FD${item.Code}`] = value
+        }
+        
+        return result
+    }
+
+    /**
+     * 解析报文
+     */
+    public static analyze(type: string, returnData: Uint8Array, fileData: Uint8Array): { success: boolean, msg: Message } {
+        const msg = new Message()
+        const packageType = PackageType[type as keyof typeof PackageType]
+        const packageInstance = MsgPackage.packageList[packageType]
+        
+        const totalData = new Uint8Array(returnData.length + fileData.length)
+        totalData.set(returnData, 0)
+        totalData.set(fileData, returnData.length)
+        
+        const success = packageInstance.analyze(msg, totalData)
+        return { success, msg }
+    }
+}
+
+// msgjson辅助类
+class MsgJson {
+    code: string = ''
+    type: string = ''
+    values: string = ''
+}

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

@@ -0,0 +1,187 @@
+import { TradeHandle } from './TradeHandle'
+
+export class FdItem {
+  Code: string = ''
+  Type: string = ''
+  Length: number = 0
+  DotLength: number = 0
+  Description: string = ''
+  FieldType: string = ''
+  MaxLength: number = 0
+  Children: FdItem[] = []
+  MetaData: Record<string, any> = {}
+
+  private static charType = ['0', '5', '6']
+  private static numberType = ['1', '2', '4']
+
+  getItemType(): 'string' | 'number' | null {
+    if (FdItem.charType.includes(this.Type)) return 'string'
+    if (FdItem.numberType.includes(this.Type)) return 'number'
+    return null
+  }
+
+  formatValue(value: any): string {
+    if (this.Children && this.Children.length > 0) {
+      throw new Error(`域[${this.Code}]存在子域，不允许执行formatValue方法！`)
+    }
+
+    let result = ''
+    switch (this.FieldType) {
+      case '-1':
+        // 该域被禁用
+        break
+      case '0':
+        // 定长域
+        if (FdItem.charType.includes(this.Type)) {
+          // 字符型域
+          const data = new Uint8Array(this.Length).fill(' '.charCodeAt(0))
+          const source = new TextEncoder().encode(value?.toString() || '')
+          const copyLength = Math.min(source.length, data.length)
+          data.set(source.subarray(0, copyLength))
+          result = new TextDecoder().decode(data)
+        } else if (FdItem.numberType.includes(this.Type)) {
+          // 数字型域
+          const data = new Uint8Array(this.Length).fill('0'.charCodeAt(0))
+          let newValue = parseFloat(value?.toString() || '0') || 0
+          
+          // 处理负数
+          if (newValue < 0) data[0] = '-'.charCodeAt(0)
+          
+          // 处理小数位
+          newValue = newValue * Math.pow(10, this.DotLength)
+          newValue = Math.abs(Math.trunc(newValue))
+          
+          const source = new TextEncoder().encode(newValue.toString())
+          const len = source.length - data.length
+          
+          if (len < 0) {
+            data.set(source, -len)
+          } else {
+            data.set(source.subarray(len))
+          }
+          result = new TextDecoder().decode(data)
+        }
+        break
+      default:
+        // 变长域
+        if (FdItem.charType.includes(this.Type)) {
+          // 字符型域
+          const source = new TextEncoder().encode(value?.toString() || '')
+          const data = source.subarray(0, Math.min(source.length, this.MaxLength))
+          result = new TextDecoder().decode(data)
+        } else if (FdItem.numberType.includes(this.Type)) {
+          // 数字型域
+          let newValue = parseFloat(value?.toString() || '0') || 0
+          newValue = newValue * Math.pow(10, this.DotLength)
+          const source = new TextEncoder().encode(newValue.toString())
+          const data = source.subarray(0, Math.min(source.length, this.MaxLength))
+          result = new TextDecoder().decode(data)
+        }
+        break
+    }
+    return result
+  }
+}
+
+export class MsgBitMap {
+  private static _instance_Server: MsgBitMap
+  private static _instance_Agn: MsgBitMap
+  private static _instance_Cnaps2: MsgBitMap
+
+  FdBitMap: Record<string, FdItem> = {}
+
+  private constructor() {}
+
+  static get Instance_Server(): MsgBitMap {
+    if (!this._instance_Server) {
+      this._instance_Server = new MsgBitMap()
+      this._instance_Server.FdBitMap = this.InitFdBitMap('Server')
+    }
+    return this._instance_Server
+  }
+
+  static get Instance_Agn(): MsgBitMap {
+    if (!this._instance_Agn) {
+      this._instance_Agn = new MsgBitMap()
+      this._instance_Agn.FdBitMap = this.InitFdBitMap('Agn')
+    }
+    return this._instance_Agn
+  }
+
+  static get Instance_Cnaps2(): MsgBitMap {
+    if (!this._instance_Cnaps2) {
+      this._instance_Cnaps2 = new MsgBitMap()
+      this._instance_Cnaps2.FdBitMap = this.InitFdBitMap('Cnaps2')
+    }
+    return this._instance_Cnaps2
+  }
+
+  private static async InitFdBitMap(type: string): Promise<Record<string, FdItem>> {
+    const dict: Record<string, FdItem> = {}
+    const data = await TradeHandle.GetFdItemMap(type)
+
+    data.forEach((item: any) => {
+      const fdItem = new FdItem()
+      fdItem.Code = item.Code
+      fdItem.Type = item.Type
+      fdItem.Length = parseInt(item.Length)
+      fdItem.DotLength = parseInt(item.DotLength)
+      fdItem.Description = item.Description
+      fdItem.FieldType = item.FieldType
+      fdItem.MaxLength = parseInt(item.MaxLength)
+      fdItem.Children = []
+      fdItem.MetaData = {}
+
+      dict[fdItem.Code] = fdItem
+      if (!fdItem.Code.endsWith('0')) {
+        const code = fdItem.Code.substring(0, 3) + '0'
+        if (dict[code]) {
+          dict[code].Children.push(fdItem)
+        }
+      }
+    })
+
+    return dict
+  }
+
+  static async CreateMessageCode(): Promise<string> {
+    const fdInfo: string[] = []
+    const fds = Object.values(MsgBitMap.Instance_Server.FdBitMap)
+
+    for (const item of fds) {
+      if (!item.Children || item.Children.length === 0) {
+        fdInfo.push(this.CreateFdCode(item))
+      } else {
+        fdInfo.push(`#region ${item.Code}域定义`)
+        for (const child of item.Children) {
+          fdInfo.push(this.CreateFdCode(child))
+        }
+        fdInfo.push('#endregion\n')
+      }
+    }
+
+    return fdInfo.join('\n')
+  }
+
+  private static CreateFdCode(fdItem: FdItem): string {
+    const fdNo = fdItem.Code.replace(/^0+/, '').slice(0, -1)
+    const fdIndex = fdItem.Code.slice(-1)
+    const isParent = fdIndex === '0'
+
+    const codeLines: string[] = []
+    codeLines.push(`#region ${fdItem.Code}域定义`)
+    codeLines.push('/**')
+    codeLines.push(` * ${isParent ? `第${fdNo}域` : `第${fdNo}域${fdIndex}子域`}`)
+    codeLines.push(' */')
+    codeLines.push(`public get ${isParent ? `Fd${fdNo}` : `Fd${fdNo}_${fdIndex}`}(): string {`)
+    codeLines.push(`  return this.GetFdVaule("${fdItem.Code}").toString()`)
+    codeLines.push('}')
+    codeLines.push('')
+    codeLines.push(`public set ${isParent ? `Fd${fdNo}` : `Fd${fdNo}_${fdIndex}`}(value: string) {`)
+    codeLines.push(`  this.SetFdValue("${fdItem.Code}", value)`)
+    codeLines.push('}')
+    codeLines.push('#endregion')
+    
+    return codeLines.join('\n')
+  }
+}

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

@@ -0,0 +1,130 @@
+import { ref } from 'vue'
+import * as fs from 'fs'
+import * as path from 'path'
+import { FilesHandle } from './FilesHandle'
+import { ServiceSettings } from './ServiceSettings'
+
+type ErrorMapValue = {
+  description: string
+  codes: Map<string, string>
+}
+
+export class TransitErrorCodeMap {
+  private static instance: TransitErrorCodeMap
+  private _errorMap = new Map<string, ErrorMapValue>()
+
+  public static GetInstance(): TransitErrorCodeMap {
+    if (!this.instance) {
+      this.instance = new TransitErrorCodeMap()
+    }
+    return this.instance
+  }
+
+  private constructor() {
+    this.initErrorMap()
+  }
+
+  private async initErrorMap() {
+    const localFile = path.join(process.cwd(), 'errorMap.xml')
+    const serverPath = path.join(ServiceSettings.ConfigFilePath, 'errorMap.xml')
+
+    // 检查文件是否需要更新
+    if (!fs.existsSync(localFile) || !(await FilesHandle.CheckMD5(localFile, serverPath))) {
+      try {
+        // 更新文件
+        if (fs.existsSync(localFile)) {
+          fs.unlinkSync(localFile)
+        }
+        const data = await FilesHandle.GetFileData(serverPath)
+        fs.writeFileSync(localFile, data)
+      } catch (e) {
+        console.error('更新错误码映射文件失败:', e)
+      }
+    }
+
+    // 读取配置文件
+    try {
+      const xmlData = fs.readFileSync(localFile, 'utf-8')
+      const parser = new DOMParser()
+      const document = parser.parseFromString(xmlData, 'text/xml')
+
+      if (document.documentElement) {
+        // 分类配置文件
+        const categories = document.documentElement.getElementsByTagName('category')
+        for (let i = 0; i < categories.length; i++) {
+          const node = categories[i]
+          const type = node.getAttribute('name')
+          if (!type || this._errorMap.has(type)) continue
+
+          const desc = node.getAttribute('value') || ''
+          const codeMap = new Map<string, string>()
+
+          const errors = node.getElementsByTagName('error')
+          for (let j = 0; j < errors.length; j++) {
+            const error = errors[j]
+            const code = error.getAttribute('name')
+            const value = error.getAttribute('value')
+            if (code && value && !codeMap.has(code)) {
+              codeMap.set(code, value)
+            }
+          }
+
+          this._errorMap.set(type, {
+            description: desc,
+            codes: codeMap
+          })
+        }
+      }
+    } catch (e) {
+      console.error('解析错误码映射文件失败:', e)
+    }
+  }
+
+  /**
+   * 获取错误代码指代的错误信息
+   */
+  public GetErrorMessage(errorCode: string, type?: string): string {
+    const errorType = type || 'default'
+    const dict = this._errorMap.get(errorType)
+    
+    if (!dict) {
+      return `[${errorType}-${errorCode}]未知的错误代码类型`
+    }
+
+    let msg = dict.codes.get(errorCode) || '未知的错误代码'
+    
+    // 若找不到错误码，从default中再找一遍
+    if (msg === '未知的错误代码' && errorType === 'agn') {
+      const defaultDict = this._errorMap.get('default')
+      if (defaultDict && defaultDict.codes.has(errorCode)) {
+        msg = defaultDict.codes.get(errorCode)!
+      }
+    }
+
+    return `[${dict.description}-${errorCode}]${msg}`
+  }
+
+  /**
+   * 获取带域信息的错误代码指代的错误信息
+   */
+  public GetErrorMessageWithField(errorCode: string, errorFd: string, type?: string): string {
+    const errorType = type || 'default'
+    const dict = this._errorMap.get(errorType)
+    
+    if (!dict) {
+      return `[${errorType}-${errorCode}]未知的错误代码类型(${errorFd})`
+    }
+
+    let msg = dict.codes.get(errorCode) || '未知的错误代码'
+    
+    // 若找不到错误码，从default中再找一遍
+    if (msg === '未知的错误代码' && errorType === 'agn') {
+      const defaultDict = this._errorMap.get('default')
+      if (defaultDict && defaultDict.codes.has(errorCode)) {
+        msg = defaultDict.codes.get(errorCode)!
+      }
+    }
+
+    return `[${dict.description}-${errorCode}]${msg}(${errorFd})`
+  }
+}

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

@@ -0,0 +1,142 @@
+/**
+ * 支持的通讯外端
+ */
+export enum TransitType {
+    /**
+     * 未知外端
+     */
+    Unknown = 0,
+    
+    /**
+     * 核心后台
+     */
+    CallServer = 1,
+    
+    /**
+     * 平台渠道
+     */
+    CallAgn = 2,
+    
+    CallMobileBanking = 3,
+    CallAgnCIS = 4,
+    CallAgnCard = 5,
+    CallAgnNew = 6,
+    CallAgnCardEx = 7,
+    CallAgnCartoon = 8,
+    CallAgnHPF = 9,
+    CallAgnTV = 10,
+    CallAgnFSSR = 11,
+    CallAgnHontax = 12,
+    CallAgnMIS = 13,
+    CallAgnWXJJ_LP = 14,
+    CallAgnWXJJ_CDX = 15,
+    CallAgnNetBank = 16,
+    CallAgnMF01 = 17,
+    CallAgnMF02 = 18,
+    CallAgnCnaps2 = 19,
+    CallAgnSHCZ = 20,
+    CallAgnIBDW = 21,
+    CallAgnHeat01 = 22,
+    CallAgnHeat02 = 23,
+    CallAgnHeat03 = 24,
+    CallAgnWater = 25,
+    CallAgnIDC = 26,
+    
+    /**
+     * 超级网银
+     */
+    CallAgnIBPS = 27,
+    
+    CallAgnOrder = 28,
+    CallAgnTips = 29,
+    CallAgnRun = 30,
+    
+    // 村镇银行网银
+    CallAgn_CZYYSW = 31,
+    
+    // 二代货币/反假币
+    CallNoFileSys = 32,
+    
+    // 青隆易缴费
+    CallAgn_EasyPay = 33,
+    
+    /**
+     * 阳光燃气费代交
+     */
+    CallAgn_GasFee = 34,
+    
+    /**
+     * 山东一窗通
+     */
+    CallAgn_SDYCT = 35,
+    
+    /**
+     * 中牟存量房监管
+     */
+    CallAgnCLFJG = 36,
+    
+    /**
+     * 农金通
+     */
+    CallAgn_NJT = 37,
+    
+    /**
+     * 青隆房管局网签
+     */
+    CallAgn_FGJWQ = 38,
+    
+    /**
+     * 阳光电子汇票
+     */
+    CallAgn_Ebill = 39,
+    
+    /**
+     * 农信银网联
+     */
+    CallAgnNew_WL = 40,
+    
+    /**
+     * 境外卡渠道
+     */
+    CallAgn_JWK = 85001,
+    
+    /**
+     * 青隆房管局网签 黄骅市
+     */
+    CallAgn_FGJWQ_HH = 30201,
+    
+    /**
+     * 扶沟 农民工工资代发
+     */
+    CallAgn_DF = 13201,
+    
+    /**
+     * 固始公积金
+     */
+    CallAgn_GGJ = 10801,
+    
+    /**
+     * 中牟超网
+     */
+    CallAgn_CW = 10201,
+    
+    /**
+     * 中牟资金监管
+     */
+    CallAgn_ZJJG = 10202,
+    
+    /**
+     * 中牟查控系统
+     */
+    CallAgn_CKXT = 10203,
+    
+    /**
+     * 核心前置通讯
+     */
+    CallGateway2CBS = 10204,
+    
+    /**
+     * 浚县房屋资金维修
+     */
+    CallHfmsApp = 16201
+}

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

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TellerSystem.Communication.Package
+{
+    interface IPackage
+    {
+
+        /// <summary>
+        /// 组包操作
+        /// </summary>
+        ///<param name="msg">核心返回数据包</param>
+        /// <returns>报文数据包</returns>
+        byte[] Integrate( Message msg);
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg">核心返回数据包</param>
+        /// <param name="data">核心返回数据包</param>
+        /// <returns></returns>
+        bool Analyze( Message msg,byte[] data);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Message } from './Message'
+
+/**
+ * 报文打包解包接口
+ */
+export interface IPackage {
+    /**
+     * 组包操作
+     * @param msg 核心返回数据包
+     * @returns 报文数据包
+     */
+    integrate(msg: Message): Uint8Array;
+
+    /**
+     * 解包操作
+     * @param msg 核心返回数据包
+     * @param data 核心返回数据包
+     * @returns 是否解包成功
+     */
+    analyze(msg: Message, data: Uint8Array): boolean;
+}

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

@@ -0,0 +1,423 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Platform.Common;
+using Platform.Common.RunningParameters;
+using Platform.Common.LogSystem;
+
+namespace TellerSystem.Communication.Package
+{
+    /// <summary>
+    /// 8583 128域类型报文，Tcp通讯方式的组包，解包处理。承德渠道
+    /// </summary>
+    class Msg858301 : IPackage
+    {
+        //定义静态实例
+        public static Msg858301 Instance;
+        /// <summary>
+        ///静态实例初始化函数
+        /// </summary>
+        static public Msg858301 GetInstance()
+        {
+            if (Instance == null)
+            {
+                Instance = new Msg858301();
+            }
+            return Instance;
+        }
+
+        /// <summary>
+        /// 组包操作
+        /// </summary>
+        /// <returns>报文数据包</returns>
+        public byte[] Integrate(Message msg)
+        {
+            byte[] returnData = null;
+
+            try
+            {
+                returnData = DoIntegrate(msg);
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("组包发生异常：", ex);
+                throw;
+            }
+            return returnData;
+        }
+
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg">核心返回数据包</param>
+        /// <param name="data">核心返回数据包</param>
+        /// <returns></returns>
+        public bool Analyze(Message msg, byte[] data)
+        {
+            try
+            {
+                //进行解包处理
+                DoAnalyze(msg, data);
+            }
+            catch (Exception ex)
+            {
+
+                return false;
+            }
+            return true;
+        }
+
+        #region 组包处理
+
+        /// <summary>
+        /// 组包处理
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <returns></returns>
+        private byte[] DoIntegrate(Message msg)
+        {
+            #region new
+            ///*******************************************
+            // * 组包规则：
+            // * msgHeader         byte[68]   Tuxedo报文头
+            // * msgData           byte[]     报文数据
+            // * fileFlag          byte       是否发送附件 
+            // * *****************************************/
+
+            ////文件标志
+            //byte fileFlag = (byte)(msg.FileFlag ? 0x7f : 0xff);
+            ////报文数据
+            //byte[] bitMapData;
+            //var fdData = msg.IntegrateFd(out bitMapData);
+            //byte[] msgKindData = PlatformSettings.Encoding.GetBytes(MsgParames.MsgType.PadLeft(5, '0'));
+            //var msgData = new byte[msgKindData.Length + bitMapData.Length + fdData.Length];
+            //msgKindData.CopyTo(msgData, 0);
+            //bitMapData.CopyTo(msgData, msgKindData.Length);
+            //fdData.CopyTo(msgData, msgKindData.Length + bitMapData.Length);
+            ////加密报文数据
+            //MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(MsgParames.KeyStr), 1);
+            ////报文头
+            //var msgHeader = GetMsgT(msg, msgData.Length.ToString()).ToArray<byte>();
+            ////组装报文
+            //var totalData = new byte[msgHeader.Length + msgData.Length + 1];
+            //msgHeader.CopyTo(totalData, 0);
+            //msgData.CopyTo(totalData, msgHeader.Length);
+            //totalData[totalData.Length - 1] = fileFlag;
+
+            //return totalData;
+            #endregion
+
+
+            #region deleted
+            //报文数据区
+            byte[] msgData;
+            //报文总长度
+            int totalLen;
+            //8位长度对应字符串
+            string strLen;
+            //报文数据区的长度
+            int msgDataLen;
+            //60位报文头
+            string msgTitle;
+            //5报文类型
+            byte[] msgKindByte;
+            //位图区域
+            byte[] bitMapByte = new byte[16];
+            //有效数据内容
+            string bitDataStr = string.Empty;
+            byte[] bitDataByte;
+            //组包数据包
+            byte[] totalMsgData;
+
+            //文件标志 0xff==no file   0x7f==file
+            byte fileFlag;
+            //根据当前交易附件标志设置文件标志
+            if (msg.FileFlag)
+            {
+                fileFlag = 0x7f;
+            }
+            //无文件
+            else
+            {
+                fileFlag = 0xff;
+            }
+            try
+            {
+                //报文类型
+                msgKindByte = PlatformSettings.Encoding.GetBytes("00000");
+                //组织报文数据区域信息，位图区，数据区
+                //GetBitData(msg, bitMapByte, ref bitDataStr);
+                //bitDataByte = PlatformSettings.Encoding.GetBytes(bitDataStr);
+                bitDataByte = msg.IntegrateFd(out bitMapByte);
+
+                //报文数据区长度
+                msgDataLen = msgKindByte.Length + bitMapByte.Length + bitDataByte.Length;
+                //报文总长度
+                totalLen = msgDataLen + 68;
+                //8位长度对应字符串
+                strLen = Convert.ToString(totalLen).PadLeft(8, '0');
+                //60位报文头
+                msgTitle = msgDataLen.ToString().PadLeft(4, '0').PadLeft(68, ' ');//GetMsgT(msg, msgDataLen.ToString());
+
+                //合并5位报文类型，位图，数据区域
+                msgData = new byte[msgDataLen];
+                //合并操作
+                for (int i = 0; i < msgData.Length; i++)
+                {
+                    if (i < msgKindByte.Length)
+                    {
+                        msgData[i] = msgKindByte[i];
+                    }
+
+                    if (i > msgKindByte.Length - 1 & i < msgKindByte.Length + bitMapByte.Length)
+                    {
+                        msgData[i] = bitMapByte[i - msgKindByte.Length];
+                    }
+                    if (i > msgKindByte.Length + bitMapByte.Length - 1)
+                    {
+                        msgData[i] = bitDataByte[i - msgKindByte.Length - bitMapByte.Length];
+                    }
+                }
+
+                //MsgPackage.LogObj.Debug("加密前数据："+PlatformSettings.Encoding.GetString(msgData));
+                //加密报文数据区
+                //MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(CommonSettings.KeyStr), 1);
+                //MsgPackage.LogObj.Debug("加密后数据：" + PlatformSettings.Encoding.GetString(msgData));
+
+                //合并组包数据
+                //8位的报文长度
+                byte[] len8 = PlatformSettings.Encoding.GetBytes(strLen);//new byte[0];
+                //报文头字节数组
+                byte[] msgTitleByte = PlatformSettings.Encoding.GetBytes(msgTitle);
+                totalMsgData = new byte[len8.Length + msgTitleByte.Length + msgData.Length + 1];
+                for (int j = 0; j < totalMsgData.Length - 1; j++)
+                {
+                    if (j < len8.Length)
+                    {
+                        totalMsgData[j] = len8[j];
+                    }
+                    if (j > len8.Length - 1 & j < len8.Length + msgTitleByte.Length)
+                    {
+                        totalMsgData[j] = msgTitleByte[j - len8.Length];
+                    }
+                    if (j > len8.Length + msgTitleByte.Length - 1)
+                    {
+                        totalMsgData[j] = msgData[j - len8.Length - msgTitleByte.Length];
+                    }
+                }
+                //设置文件标志位
+                totalMsgData[totalMsgData.Length - 1] = fileFlag;
+
+                //处理附件
+                if (msg.FileFlag)
+                {
+                    //文件追加到数据后
+                    var file = PlatformSettings.Encoding.GetBytes(Message.Cconv(msg.FileData));//生僻字转义：文件组包处理
+                    var lenData = PlatformSettings.Encoding.GetBytes(file.Length.ToString().PadLeft(8, '0'));
+                    var fileName = !string.IsNullOrEmpty(msg._filename) ? PlatformSettings.Encoding.GetBytes(msg._filename.PadRight(30)) : PlatformSettings.Encoding.GetBytes((LoginUserInfo.KinbrNo + LoginUserInfo.TtyName).PadRight(30));
+                    var ret = new byte[totalMsgData.Length + fileName.Length + lenData.Length + file.Length + 1];
+                    Array.Copy(totalMsgData, ret, totalMsgData.Length);
+                    Array.Copy(fileName, 0, ret, totalMsgData.Length, fileName.Length);
+                    Array.Copy(lenData, 0, ret, totalMsgData.Length + fileName.Length, lenData.Length);
+                    Array.Copy(file, 0, ret, totalMsgData.Length + fileName.Length + lenData.Length, file.Length);
+                    //补充一个结束字符
+                    ret[ret.Length - 1] = 0xff;
+                    totalMsgData = ret;
+                }
+                //MsgPackage.LogObj.Debug("报文整体数据：" + PlatformSettings.Encoding.GetString(totalMsgData));
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("组包发生异常！", ex);
+                throw;
+            }
+            return totalMsgData;
+            #endregion
+        }
+
+        /// <summary>
+        /// 生成TUXEDO方式报文头
+        /// </summary>
+        /// <param name="msg">域信息</param>
+        /// <param name="msgDataLen"></param>
+        /// <returns></returns>
+        private string GetMsgT(Message msg, string msgDataLen)
+        {
+            string clnm = "";                 //5位   空串
+            string svcnm = "";                //15位  Tuxedo交易服务名
+            string reqtype = "";              //1位   "4"
+            string branchNo = "";             //10位   机构编号
+            string tty = "";                  //12位   终端号
+            string titaOr8583;                //1位   代码中的值 8’
+            string cbs = "";                  //10位  空串
+            string macflg = "";               //1位   空串
+            string mac = "";                  //8位   空串
+            string result = "";               //1位   '0'
+            string len = "";                  //4位   8583数据区长度
+            //TUXEDO方式报文头
+            StringBuilder tmpMstTile = new StringBuilder();
+
+            //设置对应变量的值
+            clnm = "".PadLeft(5, ' ');
+            tmpMstTile.Append(clnm);
+            svcnm = "".PadLeft(15, ' ');
+            tmpMstTile.Append(svcnm);
+            reqtype = "4";
+            tmpMstTile.Append(reqtype);
+            //TODO:机构号扩展为10位，故报文大小变成68
+            branchNo = msg.Fd3.PadLeft(10, ' ');
+            tmpMstTile.Append(branchNo);
+            //TODO:由于tty采用12位，故修改为12位（保证核心已经修改）
+            //tty = msg.Fd10.PadLeft(9, ' ');
+            tty = msg.Fd10.PadLeft(12, ' ');
+            tmpMstTile.Append(tty);
+            titaOr8583 = "8";
+            tmpMstTile.Append(titaOr8583);
+            cbs = "".PadLeft(10, ' ');
+            tmpMstTile.Append(cbs);
+            macflg = "".PadLeft(1, ' ');
+            tmpMstTile.Append(macflg);
+            mac = "".PadLeft(8, ' ');
+            tmpMstTile.Append(mac);
+            result = "0";
+            tmpMstTile.Append(result);
+            len = msgDataLen.PadLeft(4, '0');
+            tmpMstTile.Append(len);
+
+            return tmpMstTile.ToString();
+        }
+        #endregion
+
+        #region 解包处理
+
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <param name="returnData"></param>
+        /// <returns></returns>
+        public void DoAnalyze(Message msg, byte[] returnData)
+        {
+            try
+            {
+                //丢弃前8位
+                var ret = new byte[returnData.Length - 8];
+                Array.Copy(returnData, 8, ret, 0, ret.Length);
+                returnData = ret;
+
+                //报文前68位内容       
+                byte[] msg60 = new byte[68];
+                //报文数据区长度        
+                int msgDataLen = 0;
+                //报文数据区内容
+                byte[] msgData;
+                //报文有效数据内容
+                byte[] msgDataReal;
+                //报文位图区
+                byte[] msgBit;
+                string msgBitStr = "";
+
+                //报文前60位（60位报文头）
+                for (int i = 0; i < 68; i++)
+                {
+                    msg60[i] = returnData[i];
+                }
+
+                //报文数据区长度 
+                byte[] tmpLen = new byte[4];
+                Array.Copy(msg60, 64, tmpLen, 0, 4);
+                msgDataLen = Convert.ToInt32(PlatformSettings.Encoding.GetString(tmpLen));
+
+                //报文前60位字符串内容
+                //MsgStr60 = Encoding.GetEncoding(CAppInfo.CodingStr).GetString(Msg60);
+
+                #region 20140423 王全
+                //承德平台无此返回报文场景
+                ////如果报文数据区第五位为0xff
+                ////总共报文数据区为4位应答码.
+                //if (returnData[72] == (byte)'\0')
+                //{
+                //    //应答码错误信息
+                //    byte[] tmpData = new byte[4];
+                //    //取得应答码错误信息内容
+                //    Array.Copy(returnData, 68, tmpData, 0, 4);
+                //    //返回应答码
+                //    msg.Fd12 = PlatformSettings.Encoding.GetString(tmpData);
+                //    return;
+                //}
+                #endregion
+
+                //取得报文数据区内容
+                msgData = new byte[msgDataLen];
+                Array.Copy(returnData, 68, msgData, 0, msgDataLen);
+                //文件标志
+                byte fileDataFlag = returnData[20];
+                //解密数据区内容
+                //MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(CommonSettings.KeyStr),
+                //                   0);
+                #region delete 解包封装
+                ////报文数据区格式为 5位报文类型+16位位图区域+有效数据区
+                ////报文位图区
+                ////报文位图区存在2种情况，当位图区第1域为0时，位图长度为64（压缩为8位数据），否则为128（压缩为16位数据）
+                ////标志位，是否采用128位位图
+                //bool IsBitmap128 = Convert.ToString(msgData[5], 2).PadLeft(8, '0').StartsWith("1");
+
+                //msgBit = new byte[IsBitmap128 ? 16 : 8];
+                //Array.Copy(msgData, 5, msgBit, 0, msgBit.Length);
+                ////扩展16位字符串转换为128位01格式的位图字符串
+                //foreach (byte bytes in msgBit)
+                //{
+                //    msgBitStr += Convert.ToString(bytes, 2).PadLeft(8, '0');
+                //}
+                ////写调试日志
+                ////MsgPackage.LogObj.Debug("\n返回位图:\n" + msgBitStr.Replace('\0', '\n'));
+                ////报文数据内容
+                //int startIndex = 5 + (IsBitmap128 ? 16 : 8);
+                //msgDataReal = new byte[msgDataLen - startIndex];
+                //Array.Copy(msgData, startIndex, msgDataReal, 0, msgDataReal.Length);
+                ////写调试日志
+                ////MsgPackage.LogObj.Debug("\n解包前应答数据:\n" + PlatformSettings.Encoding.GetString(msgDataReal).Replace('\0', '\n'));
+
+                ////详细解析每个域的信息
+                ////Message tmpMsg = AnilyzeFd(msgBitStr, msgDataReal, msg);
+                //if (!msg.AnilyzeFd(msgBitStr, msgDataReal))
+                //{
+                //    //解包失败
+                //    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
+                //}
+                if (!msg.AnilyzeFd(msgData))
+                {
+                    //解包失败
+                    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
+                }
+                #endregion
+                //将解析后结果复制到当前交易对象中
+                //MsgPackage.Clone(msg, tmpMsg);
+                //有文件附件的处理
+                //存在附件，规则[文件名称:30][数据长度:8][数据:n]
+                var fileLen = returnData.Length - 68 - msgDataLen - 38 - 1;
+                if (fileLen > 0)
+                {
+                    //报文文件内容               
+                    byte[] fileData = new byte[fileLen];
+                    Array.Copy(returnData, 68 + msgDataLen + 38 + 1, fileData, 0, fileLen);
+                    //返回解包后文件数据
+                    msg.FileData = Message.Cconv(PlatformSettings.Encoding.GetString(fileData), false);//生僻字转义：文件解包处理
+                    //写调试日志
+                    PlatformLogger.CommunicationInfo("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
+                }
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("解析报文失败！", ex);
+                throw;
+            }
+        }
+        #endregion
+
+    }
+}

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

@@ -0,0 +1,229 @@
+import { Message } from './Message'
+import { PlatformLogger } from './PlatformLogger'
+import { PlatformSettings } from './PlatformSettings'
+import { IPackage } from './IPackage'
+
+/**
+ * 8583 128域类型报文，Tcp通讯方式的组包，解包处理。承德渠道
+ */
+export class Msg858301 implements IPackage {
+    // 定义静态实例
+    private static _instance: Msg858301
+
+    /**
+     * 静态实例初始化函数
+     */
+    public static getInstance(): Msg858301 {
+        if (!this._instance) {
+            this._instance = new Msg858301()
+        }
+        return this._instance
+    }
+
+    /**
+     * 组包操作
+     * @param msg 核心返回数据包
+     * @returns 报文数据包
+     */
+    public integrate(msg: Message): Uint8Array {
+        let returnData: Uint8Array | null = null
+
+        try {
+            returnData = this.doIntegrate(msg)
+        } catch (ex) {
+            // 写错误信息
+            PlatformLogger.systemErrorInfo("组包发生异常：", ex)
+            throw ex
+        }
+        return returnData
+    }
+
+    /**
+     * 解包操作
+     * @param msg 核心返回数据包
+     * @param data 核心返回数据包
+     * @returns 是否解包成功
+     */
+    public analyze(msg: Message, data: Uint8Array): boolean {
+        try {
+            // 进行解包处理
+            this.doAnalyze(msg, data)
+        } catch (ex) {
+            return false
+        }
+        return true
+    }
+
+    // 组包处理
+    private doIntegrate(msg: Message): Uint8Array {
+        // 报文数据区
+        let msgData: Uint8Array
+        // 报文总长度
+        let totalLen: number
+        // 8位长度对应字符串
+        let strLen: string
+        // 报文数据区的长度
+        let msgDataLen: number
+        // 60位报文头
+        let msgTitle: string
+        // 5报文类型
+        let msgKindByte: Uint8Array
+        // 位图区域
+        let bitMapByte = new Uint8Array(16)
+        // 有效数据内容
+        let bitDataByte: Uint8Array
+        // 组包数据包
+        let totalMsgData: Uint8Array
+
+        // 文件标志 0xff==no file   0x7f==file
+        let fileFlag: number
+        // 根据当前交易附件标志设置文件标志
+        fileFlag = msg.fileFlag ? 0x7f : 0xff
+
+        try {
+            // 报文类型
+            msgKindByte = new TextEncoder().encode("00000")
+            // 组织报文数据区域信息，位图区，数据区
+            bitDataByte = msg.integrateFd(bitMapByte)
+
+            // 报文数据区长度
+            msgDataLen = msgKindByte.length + bitMapByte.length + bitDataByte.length
+            // 报文总长度
+            totalLen = msgDataLen + 68
+            // 8位长度对应字符串
+            strLen = totalLen.toString().padStart(8, '0')
+            // 60位报文头
+            msgTitle = msgDataLen.toString().padStart(4, '0').padStart(68, ' ')
+
+            // 合并5位报文类型，位图，数据区域
+            msgData = new Uint8Array(msgDataLen)
+            // 合并操作
+            for (let i = 0; i < msgData.length; i++) {
+                if (i < msgKindByte.length) {
+                    msgData[i] = msgKindByte[i]
+                }
+
+                if (i > msgKindByte.length - 1 && i < msgKindByte.length + bitMapByte.length) {
+                    msgData[i] = bitMapByte[i - msgKindByte.length]
+                }
+                if (i > msgKindByte.length + bitMapByte.length - 1) {
+                    msgData[i] = bitDataByte[i - msgKindByte.length - bitMapByte.length]
+                }
+            }
+
+            // 合并组包数据
+            // 8位的报文长度
+            const len8 = new TextEncoder().encode(strLen)
+            // 报文头字节数组
+            const msgTitleByte = new TextEncoder().encode(msgTitle)
+            totalMsgData = new Uint8Array(len8.length + msgTitleByte.length + msgData.length + 1)
+            
+            for (let j = 0; j < totalMsgData.length - 1; j++) {
+                if (j < len8.length) {
+                    totalMsgData[j] = len8[j]
+                }
+                if (j > len8.length - 1 && j < len8.length + msgTitleByte.length) {
+                    totalMsgData[j] = msgTitleByte[j - len8.length]
+                }
+                if (j > len8.length + msgTitleByte.length - 1) {
+                    totalMsgData[j] = msgData[j - len8.length - msgTitleByte.length]
+                }
+            }
+            // 设置文件标志位
+            totalMsgData[totalMsgData.length - 1] = fileFlag
+
+            // 处理附件
+            if (msg.fileFlag) {
+                // 文件追加到数据后
+                const file = new TextEncoder().encode(Message.cconv(msg.fileData))
+                const lenData = new TextEncoder().encode(file.length.toString().padStart(8, '0'))
+                const fileName = !msg._filename 
+                    ? new TextEncoder().encode(msg._filename.padEnd(30)) 
+                    : new TextEncoder().encode((msg.loginUserInfo.kinbrNo + msg.loginUserInfo.ttyName).padEnd(30))
+                
+                const ret = new Uint8Array(totalMsgData.length + fileName.length + lenData.length + file.length + 1)
+                ret.set(totalMsgData, 0)
+                ret.set(fileName, totalMsgData.length)
+                ret.set(lenData, totalMsgData.length + fileName.length)
+                ret.set(file, totalMsgData.length + fileName.length + lenData.length)
+                // 补充一个结束字符
+                ret[ret.length - 1] = 0xff
+                totalMsgData = ret
+            }
+        } catch (ex) {
+            // 写错误信息
+            PlatformLogger.systemErrorInfo("组包发生异常！", ex)
+            throw ex
+        }
+        return totalMsgData
+    }
+
+    // 解包处理
+    private doAnalyze(msg: Message, returnData: Uint8Array): void {
+        try {
+            // 丢弃前8位
+            const ret = new Uint8Array(returnData.length - 8)
+            ret.set(returnData.subarray(8), 0)
+            returnData = ret
+
+            // 报文前68位内容       
+            const msg60 = new Uint8Array(68)
+            // 报文数据区长度        
+            let msgDataLen = 0
+            // 报文数据区内容
+            let msgData: Uint8Array
+
+            // 报文前60位（60位报文头）
+            msg60.set(returnData.subarray(0, 68), 0)
+
+            // 报文数据区长度 
+            const tmpLen = new Uint8Array(4)
+            tmpLen.set(msg60.subarray(64, 68), 0)
+            msgDataLen = parseInt(new TextDecoder().decode(tmpLen))
+
+            // 取得报文数据区内容
+            msgData = new Uint8Array(msgDataLen)
+            msgData.set(returnData.subarray(68, 68 + msgDataLen), 0)
+            
+            if (!msg.anilyzeFd(msgData)) {
+                // 解包失败
+                throw new Error("8583通讯解包操作失败！具体情况请查看日志！")
+            }
+
+            // 有文件附件的处理
+            const fileLen = returnData.length - 68 - msgDataLen - 38 - 1
+            if (fileLen > 0) {
+                // 报文文件内容               
+                const fileData = new Uint8Array(fileLen)
+                fileData.set(returnData.subarray(68 + msgDataLen + 38 + 1, 68 + msgDataLen + 38 + 1 + fileLen), 0)
+                // 返回解包后文件数据
+                msg.fileData = Message.cconv(new TextDecoder().decode(fileData), false)
+                // 写调试日志
+                PlatformLogger.communicationInfo("\n文件数据:\n" + new TextDecoder().decode(fileData))
+            }
+        } catch (ex) {
+            // 写错误信息
+            PlatformLogger.systemErrorInfo("解析报文失败！", ex)
+            throw ex
+        }
+    }
+
+    // 生成TUXEDO方式报文头
+    private getMsgT(msg: Message, msgDataLen: string): string {
+        const clnm = "".padStart(5, ' ')         //5位   空串
+        const svcnm = "".padStart(15, ' ')        //15位  Tuxedo交易服务名
+        const reqtype = "4"                       //1位   "4"
+        const branchNo = msg.fd3.padStart(10, ' ') //10位   机构编号
+        const tty = msg.fd10.padStart(12, ' ')    //12位   终端号
+        const titaOr8583 = "8"                    //1位   代码中的值 8'
+        const cbs = "".padStart(10, ' ')          //10位  空串
+        const macflg = "".padStart(1, ' ')        //1位   空串
+        const mac = "".padStart(8, ' ')           //8位   空串
+        const result = "0"                        //1位   '0'
+        const len = msgDataLen.padStart(4, '0')   //4位   8583数据区长度
+
+        // TUXEDO方式报文头
+        return clnm + svcnm + reqtype + branchNo + tty + titaOr8583 + 
+               cbs + macflg + mac + result + len
+    }
+}

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

@@ -0,0 +1,203 @@
+import { Message } from './Message'
+import { PlatformLogger } from './PlatformLogger'
+import { PlatformSettings } from './PlatformSettings'
+import { IPackage } from './IPackage'
+import { MsgPackage } from './MsgPackage'
+import { CommonSettings } from './CommonSettings'
+
+/**
+ * 8583 128域类型报文，Tuxedo通讯方式的组包，解包处理。
+ */
+export class Msg858302 implements IPackage {
+    // 定义静态实例
+    private static _instance: Msg858302
+
+    /**
+     * 静态实例初始化函数
+     */
+    public static getInstance(): Msg858302 {
+        if (!this._instance) {
+            this._instance = new Msg858302()
+        }
+        return this._instance
+    }
+
+    /**
+     * 组包操作
+     * @param msg 核心返回数据包
+     * @returns 报文数据包
+     */
+    public integrate(msg: Message): Uint8Array {
+        let returnData: Uint8Array | null = null
+
+        try {
+            returnData = this.doIntegrate(msg)
+        } catch (ex) {
+            // 写错误信息
+            PlatformLogger.systemErrorInfo("组包发生异常：", ex)
+            throw ex
+        }
+        return returnData
+    }
+
+    /**
+     * 解包操作
+     * @param msg 核心返回数据包
+     * @param data 核心返回数据包
+     * @returns 是否解包成功
+     */
+    public analyze(msg: Message, data: Uint8Array): boolean {
+        try {
+            // 进行解包处理
+            this.doAnalyze(msg, data)
+        } catch (ex) {
+            return false
+        }
+        return true
+    }
+
+    // 组包处理
+    private doIntegrate(msg: Message): Uint8Array {
+        // 报文数据区
+        let msgData: Uint8Array
+        // 报文总长度
+        let totalLen: number
+        // 8位长度对应字符串
+        let strLen: string
+        // 报文数据区的长度
+        let msgDataLen: number
+        // 60位报文头
+        let msgTitle: string
+        // 5报文类型
+        let msgKindByte: Uint8Array
+        // 位图区域
+        let bitMapByte = new Uint8Array(16)
+        // 有效数据内容
+        let bitDataByte: Uint8Array
+        // 组包数据包
+        let totalMsgData: Uint8Array
+
+        // 文件标志 0xff==no file   0x7f==file
+        let fileFlag: number
+        // 根据当前交易附件标志设置文件标志
+        fileFlag = msg.fileFlag ? 0x7f : 0xff
+
+        try {
+            // 报文类型
+            msgKindByte = new TextEncoder().encode("00001")
+            // 组织报文数据区域信息，位图区，数据区
+            bitDataByte = msg.integrateFd(bitMapByte)
+
+            // 报文数据区长度
+            msgDataLen = msgKindByte.length + bitMapByte.length + bitDataByte.length
+            // 报文总长度
+            totalLen = msgDataLen + 68
+            // 8位长度对应字符串
+            strLen = totalLen.toString().padStart(8, '0')
+            // 60位报文头
+            msgTitle = this.getMsgT(msg, msgDataLen.toString())
+
+            // 合并5位报文类型，位图，数据区域
+            msgData = new Uint8Array(msgDataLen)
+            // 合并操作
+            for (let i = 0; i < msgData.length; i++) {
+                if (i < msgKindByte.length) {
+                    msgData[i] = msgKindByte[i]
+                }
+
+                if (i > msgKindByte.length - 1 && i < msgKindByte.length + bitMapByte.length) {
+                    msgData[i] = bitMapByte[i - msgKindByte.length]
+                }
+                if (i > msgKindByte.length + bitMapByte.length - 1) {
+                    msgData[i] = bitDataByte[i - msgKindByte.length - bitMapByte.length]
+                }
+            }
+
+            // 加密报文数据区
+            MsgPackage.encrypt(msgData, new TextEncoder().encode(CommonSettings.keyStr), 1)
+
+            // 合并组包数据
+            // tuxedo报文头前面没有8位的报文长度
+            const len8 = new Uint8Array(0)
+            // 报文头字节数组
+            const msgTitleByte = new TextEncoder().encode(msgTitle)
+            totalMsgData = new Uint8Array(len8.length + msgTitleByte.length + msgData.length + 1)
+            
+            for (let j = 0; j < totalMsgData.length - 1; j++) {
+                if (j < len8.length) {
+                    totalMsgData[j] = len8[j]
+                }
+                if (j > len8.length - 1 && j < len8.length + msgTitleByte.length) {
+                    totalMsgData[j] = msgTitleByte[j - len8.length]
+                }
+                if (j > len8.length + msgTitleByte.length - 1) {
+                    totalMsgData[j] = msgData[j - len8.length - msgTitleByte.length]
+                }
+            }
+            // 设置文件标志位
+            totalMsgData[totalMsgData.length - 1] = fileFlag
+        } catch (ex) {
+            // 写错误信息
+            PlatformLogger.systemErrorInfo("组包发生异常！", ex)
+            throw ex
+        }
+        return totalMsgData
+    }
+
+    /**
+     * 生成TUXEDO方式报文头
+     * @param msg 域信息
+     * @param msgDataLen 报文数据长度
+     * @returns 报文头字符串
+     */
+    private getMsgT(msg: Message, msgDataLen: string): string {
+        const clnm = "".padStart(5, ' ')         //5位   空串
+        const svcnm = "".padStart(15, ' ')       //15位  Tuxedo交易服务名
+        const reqtype = "4"                      //1位   "4"
+        const branchNo = msg.fd3.padStart(10, ' ') //10位   机构编号
+        const tty = msg.fd10.padStart(12, ' ')   //12位   终端号
+        const titaOr8583 = "8"                   //1位   代码中的值 8'
+        const cbs = "".padStart(10, ' ')         //10位  空串
+        const macflg = "".padStart(1, ' ')       //1位   空串
+        const mac = "".padStart(8, ' ')          //8位   空串
+        const result = "0"                       //1位   '0'
+        const len = msgDataLen.padStart(4, '0')  //4位   8583数据区长度
+
+        // TUXEDO方式报文头
+        return clnm + svcnm + reqtype + branchNo + tty + titaOr8583 + 
+               cbs + macflg + mac + result + len
+    }
+
+    // 解包处理
+    private doAnalyze(msg: Message, returnData: Uint8Array): void {
+        try {
+            // 报文前68位内容       
+            const msg60 = new Uint8Array(68)
+            // 报文数据区长度        
+            let msgDataLen = 0
+            // 报文数据区内容
+            let msgData: Uint8Array
+
+            // 报文前60位（60位报文头）
+            msg60.set(returnData.subarray(0, 68), 0)
+
+            // 报文数据区长度 
+            const tmpLen = new Uint8Array(4)
+            tmpLen.set(msg60.subarray(64, 68), 0)
+            msgDataLen = parseInt(new TextDecoder().decode(tmpLen))
+
+            // 取得报文数据区内容
+            msgData = new Uint8Array(msgDataLen)
+            msgData.set(returnData.subarray(68, 68 + msgDataLen), 0)
+            
+            if (!msg.anilyzeFd(msgData)) {
+                // 解包失败
+                throw new Error("8583通讯解包操作失败！具体情况请查看日志！")
+            }
+        } catch (ex) {
+            // 写错误信息
+            PlatformLogger.systemErrorInfo("解析报文失败！", ex)
+            throw ex
+        }
+    }
+}

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

@@ -0,0 +1,894 @@
+using System;
+using System.Text;
+using Platform.Common;
+using Platform.Common.RunningParameters;
+using Platform.Common.LogSystem;
+using TellerSystem.Communication.MessageHelper;
+
+namespace TellerSystem.Communication.Package
+{
+    /// <summary>
+    /// 8583 128域类型报文，TCP通讯方式的组包，解包处理。
+    /// </summary>
+    class Msg858303 : IPackage
+    {
+        //定义静态实例
+        public static Msg858303 Instance;
+        /// <summary>
+        ///静态实例初始化函数
+        /// </summary>
+        static public Msg858303 GetInstance()
+        {
+            if (Instance == null)
+            {
+                Instance = new Msg858303();
+            }
+            return Instance;
+        }
+
+        /// <summary>
+        /// 组包操作
+        /// </summary>
+        /// <returns>报文数据包</returns>
+        public byte[] Integrate(Message msg)
+        {
+            byte[] returnData = null;
+
+            try
+            {
+                returnData = DoIntegrate(msg);
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                //MsgPackage.LogObj.Error(ex.Message);
+                throw;
+            }
+            return returnData;
+        }
+
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg">核心返回数据包</param>
+        /// <param name="data">核心返回数据包</param>
+        /// <returns></returns>
+        public bool Analyze(Message msg, byte[] data)
+        {
+            try
+            {
+                //进行解包处理
+                DoAnalyze(msg, data);
+            }
+            catch (Exception ex)
+            {
+
+                return false;
+            }
+            return true;
+        }
+
+        #region 组包处理
+
+        /// <summary>
+        /// 组包处理
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <returns></returns>
+        private byte[] DoIntegrate(Message msg)
+        {
+            //报文数据区
+            byte[] msgData;
+            //报文总长度
+            int totalLen;
+            //8位长度对应字符串
+            string strLen;
+            //报文数据区的长度
+            int msgDataLen;
+            //60位报文头
+            string msgTitle;
+            //5报文类型
+            byte[] msgKindByte;
+            //位图区域
+            byte[] bitMapByte = new byte[16];
+            //有效数据内容
+            string bitDataStr = string.Empty;
+            byte[] bitDataByte;
+            //组包数据包
+            byte[] totalMsgData;
+
+            //文件标志 0xff==no file   0x7f==file
+            byte fileFlag;
+            //根据当前交易附件标志设置文件标志
+            if (msg.FileFlag)
+            {
+                fileFlag = 0x7f;
+            }
+            //无文件
+            else
+            {
+                fileFlag = 0xff;
+            }
+            try
+            {
+                //报文类型
+                msgKindByte = PlatformSettings.Encoding.GetBytes("     ");
+                //组织报文数据区域信息，位图区，数据区
+                //GetBitData(msg, bitMapByte, ref bitDataStr);
+                //bitDataByte = PlatformSettings.Encoding.GetBytes(bitDataStr);
+                bitDataByte = msg.IntegrateFd(out bitMapByte);
+
+                //报文数据区长度
+                msgDataLen = msgKindByte.Length + bitMapByte.Length + bitDataByte.Length;
+                //报文总长度
+                totalLen = msgDataLen + 63;
+                //8位长度对应字符串
+                strLen = Convert.ToString(totalLen).PadLeft(8, '0');
+                //60位报文头
+                msgTitle = Convert.ToString(msgDataLen).PadLeft(4, '0');
+                //lianyintong 报文头要求
+                //00:渠道编号,00:系统编号
+                msgTitle = "0000" + "MDBS1" + "    ";
+
+                msgTitle = msgTitle.PadRight(63, ' ');
+
+                //合并5位报文类型，位图，数据区域
+                msgData = new byte[msgDataLen];
+                //合并操作
+                for (int i = 0; i < msgData.Length; i++)
+                {
+                    if (i < msgKindByte.Length)
+                    {
+                        msgData[i] = msgKindByte[i];
+                    }
+
+                    if (i > msgKindByte.Length - 1 & i < msgKindByte.Length + bitMapByte.Length)
+                    {
+                        msgData[i] = bitMapByte[i - msgKindByte.Length];
+                    }
+                    if (i > msgKindByte.Length + bitMapByte.Length - 1)
+                    {
+                        msgData[i] = bitDataByte[i - msgKindByte.Length - bitMapByte.Length];
+                    }
+                }
+                //合并组包数据
+                byte[] len8 = PlatformSettings.Encoding.GetBytes(strLen);
+                //报文头字节数组
+                byte[] msgTitleByte = PlatformSettings.Encoding.GetBytes(msgTitle);
+                totalMsgData = new byte[len8.Length + msgTitleByte.Length + msgData.Length];
+                for (int j = 0; j < totalMsgData.Length - 1; j++)
+                {
+                    if (j < len8.Length)
+                    {
+                        totalMsgData[j] = len8[j];
+                    }
+                    if (j > len8.Length - 1 & j < len8.Length + msgTitleByte.Length)
+                    {
+                        totalMsgData[j] = msgTitleByte[j - len8.Length];
+                    }
+                    if (j > len8.Length + msgTitleByte.Length - 1)
+                    {
+                        totalMsgData[j] = msgData[j - len8.Length - msgTitleByte.Length];
+                    }
+                }
+                //设置文件标志位
+                //totalMsgData[totalMsgData.Length - 1] = fileFlag;
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                //MsgPackage.LogObj.Error(ex.Message);
+                throw;
+            }
+            return totalMsgData;
+        }
+
+        /// <summary>
+        /// 生成报文位图区，数据区
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <param name="bitMap"></param>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        private void GetBitData(Message msg, byte[] bitMap, ref string data)
+        {
+            //当前域数据
+            string curData = "";
+            StringBuilder tmpStr = new StringBuilder();
+            StringBuilder logStr = new StringBuilder();
+            try
+            {
+                //位图字符串
+                //初始化位图区域(都为零)
+                string bitStr = "0".PadLeft(128, '0'); ;
+                //128位位图数组
+                byte[] bitByte = PlatformSettings.Encoding.GetBytes(bitStr);
+                //8583(128)类型报文第一位图值为1
+                bitByte[0] = Convert.ToByte('1');
+
+                //设置对应位图值
+                for (int i = 1; i < 128; i++)
+                {
+                    curData = "";
+                    //取得当前域的数据
+                    logStr.Append(GetBitItemData(msg, i + 1, ref curData));
+
+                    //处理当前域位图信息
+                    //当前域值不为空时，对应位图为1.
+                    if (curData != "")
+                    {
+                        bitByte[i] = Convert.ToByte('1');
+                        //处理当前域的数据信息
+                        //每个域的内容里不允许有‘\0'和'\r'，将‘\0’替换为‘ ’
+                        curData = curData.Replace('\0', ' ').Replace('\n', ' ').Replace('\r', ' ');
+                        tmpStr.Append(curData);
+                    }
+                }
+                //位图字符串
+                bitStr = PlatformSettings.Encoding.GetString(bitByte);
+                //写位图信息
+                //MsgPackage . LogObj.Debug("\n请求位图：\n" + bitStr.Replace( '\0','\n'));
+                //写报文数据信息
+                //MsgPackage.LogObj.Info("\n请求数据：\n" + logStr.ToString());
+                PlatformLogger.CommunicationInfo("\n请求数据：\n" + logStr.ToString());
+                //转换为16位字符串)));))
+                for (int j = 0; j < 16; j++)
+                {
+                    int k = (j) * 8;
+                    bitMap[j] = Convert.ToByte(Convert.ToInt32(bitStr.Substring(k, 8), 2));
+                }
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("获取8583位图数据出现异常！", ex);
+                throw;
+            }
+            data = tmpStr.ToString();
+        }
+
+        /// <summary>
+        /// 处理某一域的数据内容
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <param name="i">当前域序号</param>
+        /// <param name="curData">当前域数据</param>
+        /// <returns>日志信息</returns>
+        private static string GetBitItemData(Message msg, int i, ref string curData)
+        {
+            #region 采用新的报文结构
+            //MsgBitMap msgBitMap = new MsgBitMap();
+            ////取得当前域的数据内容
+            //string tmpStr00 = string.Empty;
+            //string tmpStr01 = "Fd" + Convert.ToString(i + 1);
+            //string tmpFalg01 = "Flag" + Convert.ToString(i + 1);
+            //string tmpStr02 = "Bit" + Convert.ToString(i + 1);
+            //string length = MsgBitMap.BitMap[i, 0];
+            //int tmpLen = 0;
+            //string tmpData = "";
+            //bool tmpFlag = false;
+            //string[,] bitMap;
+            //string returnStr = "";
+            //string tmpStr = "";
+            //switch (length)
+            //{
+            //    //停用
+            //    case "-1":
+            //        {
+            //            break;
+            //        }
+            //    //定长
+            //    case "0":
+            //        {
+            //            //无子域
+            //            if (MsgBitMap.BitMap[i, 3] == "0")
+            //            {
+            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr01).GetValue(msg, null), "").ToString();
+            //                //当前域有数据
+            //                if (tmpData != "")
+            //                {
+            //                    curData = CommomFunctions.GetLenStr(tmpData, Convert.ToInt32(MsgBitMap.BitMap[i, 1]), false);
+            //                    //日志信息
+            //                    returnStr = tmpStr01 + ":[" + curData + "]\n";
+            //                }
+            //            }
+            //            //有子域
+            //            else if (MsgBitMap.BitMap[i, 3] == "1")
+            //            {
+            //                tmpStr00 = tmpStr01 + "_00";
+            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr00).GetValue(msg, null), "").ToString();
+            //                if (tmpData != "")
+            //                {
+            //                    tmpFlag = true;
+            //                    curData = tmpData;
+            //                    //日志信息
+            //                    returnStr = tmpStr00 + ":[" + curData + "]\n";
+            //                }
+            //                else
+            //                {
+            //                    tmpFlag =
+            //                        Convert.ToBoolean(
+            //                            CommomFunctions.NVL(msg.GetType().GetProperty(tmpFalg01).GetValue(msg, null), ""));
+            //                    if (tmpFlag)
+            //                    {
+            //                        bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
+            //                        for (int j = 0; j < (bitMap.Length / 3); j++)
+            //                        {
+            //                            //定长
+            //                            if (bitMap[j, 0] == "0")
+            //                            {
+            //                                //取得当前子域的数据
+            //                                string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');
+            //                                tmpStr = CommomFunctions.GetLenStr(
+            //                                    CommomFunctions.NVL(
+            //                                        msg.GetType().GetProperty(tmpStr01Sub).GetValue(msg, null), "").
+            //                                        ToString
+            //                                        (), Convert.ToInt32(bitMap[j, 1]), false);
+            //                                curData += tmpStr;
+            //                                //日志信息
+            //                                returnStr += tmpStr01Sub + ":[" + tmpStr + "]\n";
+            //                            }
+            //                            //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
+            //                            else
+            //                            {
+            //                            }
+            //                        }
+            //                    }
+            //                }
+            //                curData = CommomFunctions.GetLenStr(curData, Convert.ToInt32(MsgBitMap.BitMap[i, 1]),
+            //                                                           false);
+            //            }
+            //            break;
+            //        }
+            //    //变长
+            //    default:
+            //        {
+            //            //无子域
+            //            if (MsgBitMap.BitMap[i, 3] == "0")
+            //            {
+            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr01).GetValue(msg, null), "").ToString();
+            //                //当前域有数据
+            //                if (tmpData != "")
+            //                {
+            //                    tmpFlag = true;
+            //                    curData = tmpData;
+            //                    //日志信息
+            //                    returnStr = tmpStr01 + ":[" + curData + "]\n";
+            //                }
+            //            }
+            //            //有子域
+            //            else if (MsgBitMap.BitMap[i, 3] == "1")
+            //            {
+            //                tmpStr00 = tmpStr01 + "_00";
+            //                tmpData = CommomFunctions.NVL(msg.GetType().GetProperty(tmpStr00).GetValue(msg, null), "").ToString();
+            //                if (tmpData != "")
+            //                {
+            //                    tmpFlag = true;
+            //                    curData = tmpData;
+            //                    //日志信息
+            //                    returnStr = tmpStr00 + ":[" + curData + "]\n";
+            //                }
+            //                else
+            //                {
+            //                    tmpFlag =
+            //                        Convert.ToBoolean(
+            //                            CommomFunctions.NVL(msg.GetType().GetProperty(tmpFalg01).GetValue(msg, null), ""));
+            //                    //当前域有数据
+            //                    if (tmpFlag)
+            //                    {
+            //                        bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
+            //                        for (int j = 0; j < (bitMap.Length / 3); j++)
+            //                        {
+            //                            //定长
+            //                            if (bitMap[j, 0] == "0")
+            //                            {
+            //                                //取得当前子域的数据
+            //                                string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');
+            //                                tmpStr = CommomFunctions.GetLenStr(
+            //                                    CommomFunctions.NVL(
+            //                                        msg.GetType().GetProperty(tmpStr01Sub).GetValue(msg, null), "").
+            //                                        ToString
+            //                                        (), Convert.ToInt32(bitMap[j, 1]), false);
+            //                                curData += tmpStr;
+            //                                //日志信息
+            //                                returnStr += tmpStr01Sub + ":[" + tmpStr + "]\n";
+            //                            }
+            //                            //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
+            //                            else
+            //                            {
+            //                            }
+            //                        }
+            //                    }
+            //                }
+            //            }
+            //            if (tmpFlag)
+            //            {
+            //                //长度大于最大长度
+            //                tmpLen = PlatformSettings.Encoding.GetByteCount(curData);
+            //                if (tmpLen > Convert.ToInt32(MsgBitMap.BitMap[i, 1]))
+            //                {
+            //                    //从开始位置截取变量，变量长度不允许大于最大长度
+            //                    curData = CommomFunctions.GetLenStr(curData,
+            //                                                        Convert.ToInt32(MsgBitMap.BitMap[i, 1]),
+            //                                                        false);
+            //                }
+            //                //生成当前域内容
+            //                curData = tmpLen.ToString().PadLeft(Convert.ToInt16(length), '0') + curData;
+            //            }
+            //            break;
+            //        }
+            //}
+
+            //return returnStr;
+            #endregion
+
+            #region 新的处理方法
+            var result = string.Empty;
+            var fdName = i.ToString().PadLeft(3, '0') + "0";
+            if (!msg.BitMapInstance.FdBitMap.ContainsKey(fdName))
+                throw new ArgumentOutOfRangeException(string.Format("Fd报文定义集合中未找到Code等于[{0}]的域定义！", fdName));
+            var fdItem = msg.BitMapInstance.FdBitMap[fdName];
+
+            if (fdItem.Children == null || fdItem.Children.Count == 0)
+            {
+                //无子域
+                result = msg.GetFdFormatValue(fdItem.Code);
+            }
+            else
+            {
+                //有子域，子域暂时只存在定长域
+                var child = new StringBuilder();
+                foreach (var item in fdItem.Children)
+                {
+                    child.Append(msg.GetFdFormatValue(item.Code));
+                }
+                result = child.ToString();
+            }
+            switch (fdItem.FieldType)
+            {
+                case "-1":
+                    {
+                        //不使用该域
+                        result = string.Empty;
+                        break;
+                    }
+                case "0":
+                    {
+                        //定长域
+                        //判断长度，暂时不考虑子域合集长度与大域长度不一致的情况
+                        break;
+                    }
+                default:
+                    {
+                        //变长域
+                        var len = int.Parse(fdItem.FieldType);
+                        var data = PlatformSettings.Encoding.GetBytes(result);
+                        if (data.Length > 0)
+                        {
+                            if (data.Length > fdItem.Length)
+                            {
+                                byte[] tmp = new byte[fdItem.Length];
+                                Array.Copy(data, tmp, fdItem.Length);
+                                data = tmp;
+                            }
+                            var length = data.Length.ToString().PadLeft(len, '0');
+                            result = length + PlatformSettings.Encoding.GetString(data);
+                        }
+                        break;
+                    }
+            }
+            //组装返回域内容和日志信息
+            curData = result;
+            return string.Format("FD{0}:[{1}]", fdItem.Code, result);
+            #endregion
+        }
+
+        #endregion
+
+        #region 解包处理
+
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <param name="returnData"></param>
+        /// <returns></returns>
+        public void DoAnalyze(Message msg, byte[] returnData)
+        {
+            try
+            {
+                //报文前68位内容       
+                byte[] msg68 = new byte[71];
+                string msgStr68 = "";
+                //报文总长度
+                int msgTotalLen = 0;
+                //报文数据区长度        
+                int msgDataLen = 0;
+                //报文数据区内容
+                byte[] msgData;
+                //报文有效数据内容
+                byte[] msgDataReal;
+                //报文位图区
+                byte[] msgBit;
+                string msgBitStr = "";
+                //报文前68位（8位报文长度+60位报文头）
+                for (int i = 0; i < 71; i++)
+                {
+                    msg68[i] = returnData[i];
+                }
+                //报文前68位字符串内容
+                msgStr68 = PlatformSettings.Encoding.GetString(msg68);
+                //报文总长度              
+                msgTotalLen = Convert.ToInt32(msgStr68.Substring(0, 8));
+                //报文有效数据内容长度
+                msgDataLen = msgTotalLen - 63;
+                //取得报文数据区内容
+                msgData = new byte[msgDataLen];
+                Array.Copy(returnData, 71, msgData, 0, msgTotalLen - 63);
+
+                //文件标志
+                //byte fileDataFlag = returnData[msgTotalLen + 8];
+
+                #region delete 解包封装
+                ////报文数据区格式为 5位报文类型+16位位图区域+有效数据区
+                ////报文位图区
+                //msgBit = new byte[16];
+                //Array.Copy(msgData, 5, msgBit, 0, 16);
+                ////扩展16位字符串转换为128位01格式的位图字符串
+                //foreach (byte bytes in msgBit)
+                //{
+                //    msgBitStr += Convert.ToString(bytes, 2).PadLeft(8, '0');
+                //}
+                ////写调试日志
+                ////MsgPackage.LogObj.Debug("\n位图:\n" + msgBitStr);
+                //PlatformLogger.CommunicationInfo("\n位图:\n" + msgBitStr);
+                ////报文数据内容
+                //msgDataReal = new byte[msgDataLen - 21];
+                //Array.Copy(msgData, 21, msgDataReal, 0, msgDataLen - 21);
+                ////写调试日志
+                ////MsgPackage.LogObj.Debug("数据:\n" + PlatformSettings.Encoding.GetString(msgDataReal));
+                //PlatformLogger.CommunicationInfo("数据:\n" + PlatformSettings.Encoding.GetString(msgDataReal));
+                ////详细解析每个域的信息
+                ////Message tmpMsg = AnilyzeFd(msgBitStr, msgDataReal);
+                //if (!msg.AnilyzeFd(msgBitStr, msgDataReal))
+                //{
+                //    //解包失败
+                //    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
+                //}
+                if (!msg.AnilyzeFd(msgData))
+                {
+                    //解包失败
+                    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
+                }
+                #endregion
+
+                //将解析后结果复制到当前交易对象中
+                //MsgPackage.Clone(msg, tmpMsg);
+                //有文件附件的处理
+                //if (fileDataFlag == 0x7f)
+                //{
+                //    //取得文件长度
+                //    //文件部分的格式为：30位的文件名+8位的文件长度+文件内容
+                //    Int64 fileLen = returnData.Length - msgTotalLen - 9 - 30 - 8;
+                //    //报文文件内容               
+                //    byte[] fileData = new byte[fileLen];
+                //    Array.Copy(returnData, msgTotalLen + 47, fileData, 0, fileLen);
+                //    //返回解包后文件数据
+                //    msg.FileData = PlatformSettings.Encoding.GetString(fileData);
+                //    //写调试日志
+                //    //MsgPackage.LogObj.Debug("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
+                //    PlatformLogger.CommunicationInfo("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
+                //}
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                //MsgPackage.LogObj.Error(ex.Message);
+                PlatformLogger.SystemErrorInfo("报文解包出现异常！", ex);
+                throw;
+            }
+        }
+
+        #region 解包域数据部分将封装到Message对象中去
+        ///// <summary>
+        ///// 解析数据域详细数据
+        ///// </summary>
+        ///// <param name="bitMapValue"></param>
+        ///// <param name="data"></param>
+        ///// <returns></returns>
+        //private Message AnilyzeFd(string bitMapValue, byte[] data)
+        //{
+        //    Int64 curPosition = 0;
+        //    //临时数据存储对象
+        //    Message tmpMsg = new Message();
+        //    //MsgBitMap msgBitMap = new MsgBitMap();
+        //    string[,] bitMap;
+        //    StringBuilder logStr = new StringBuilder();
+        //    try
+        //    {
+        //        for (int i = 0; i < bitMapValue.Length; i++)
+        //        {
+        //            if (bitMapValue[i] == '1')
+        //            {
+        //                //第一位为标志位
+        //                if (i + 1 == 1)
+        //                {
+        //                    continue;
+        //                }
+
+        //                #region 旧的处理方案
+        //                ////当前域的类型
+        //                //string length = MsgBitMap.BitMap[i, 0];
+        //                ////取得当前域的数据内容
+        //                //string tmpStr01 = "Fd" + Convert.ToString(i + 1);
+        //                //string tmpStr02 = "Bit" + Convert.ToString(i + 1);
+        //                //switch (length)
+        //                //{
+        //                //    //停用
+        //                //    case "-1":
+        //                //        {
+        //                //            break;
+        //                //        }
+        //                //    //定长
+        //                //    case "0":
+        //                //        {
+        //                //            Int64 tmpLen = Convert.ToInt64(MsgBitMap.BitMap[i, 1]);
+        //                //            //初始化字节数组
+        //                //            byte[] tmpData = new byte[tmpLen];
+        //                //            //取得当前域字节数据
+        //                //            for (int n = 0; n < tmpLen; n++)
+        //                //            {
+        //                //                tmpData[n] = data[curPosition + n];
+        //                //            }
+        //                //            //新位置
+        //                //            curPosition = curPosition + tmpLen;
+
+        //                //            //无子域))
+        //                //            if (MsgBitMap.BitMap[i, 3] == "0")
+        //                //            {
+        //                //                tmpMsg.GetType().GetProperty(tmpStr01).SetValue(tmpMsg,
+        //                //                                                             Encoding.GetEncoding(
+        //                //                                                                 CommonParames.Coding).GetString(
+        //                //                                                                     tmpData), null);
+        //                //                //日志信息
+        //                //                logStr.Append(tmpStr01 + ":[" + Encoding.GetEncoding(
+        //                //                    CommonParames.Coding).GetString(
+        //                //                        tmpData) + "]\n");
+        //                //            }
+        //                //            //有子域
+        //                //            else if (MsgBitMap.BitMap[i, 3] == "1")
+        //                //            {
+        //                //                //取得0子域的数据
+        //                //                string tmpStr01Sub0 = tmpStr01 + "_" + "".PadLeft(2, '0');
+        //                //                tmpMsg.GetType().GetProperty(tmpStr01Sub0).SetValue(tmpMsg,
+        //                //                                                             Encoding.GetEncoding(
+        //                //                                                                 CommonParames.Coding).GetString(
+        //                //                                                                     tmpData), null);
+        //                //                //日志信息
+        //                //                logStr.Append(tmpStr01Sub0 + ":[" + Encoding.GetEncoding(
+        //                //                    CommonParames.Coding).GetString(
+        //                //                        tmpData) + "]\n");
+
+        //                //                Int64 tempPosition = 0;
+        //                //                bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
+        //                //                for (int j = 0; j < (bitMap.Length / 3); j++)
+        //                //                {
+        //                //                    //定长
+        //                //                    if (bitMap[j, 0] == "0")
+        //                //                    {
+        //                //                        //取得当前子域的数据
+        //                //                        string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');
+
+        //                //                        byte[] tmpCurData = new byte[Convert.ToInt64(bitMap[j, 1])];
+        //                //                        Array.Copy(tmpData, tempPosition, tmpCurData, 0,
+        //                //                                   Convert.ToInt64(bitMap[j, 1]));
+        //                //                        //给对应子域赋值
+        //                //                        tmpMsg.GetType().GetProperty(tmpStr01Sub).SetValue(tmpMsg,
+        //                //                                                                     Encoding.GetEncoding(
+        //                //                                                                         CommonParames.Coding).
+        //                //                                                                         GetString(tmpCurData), null);
+        //                //                        //日志信息
+        //                //                        logStr.Append(tmpStr01Sub + ":[" + Encoding.GetEncoding(
+        //                //                                                                         CommonParames.Coding).
+        //                //                                                                         GetString(tmpCurData) + "]\n");
+
+        //                //                        tempPosition += Convert.ToInt64(bitMap[j, 1]);
+
+        //                //                    }
+        //                //                    //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
+        //                //                    else
+        //                //                    {
+        //                //                    }
+        //                //                }
+        //                //            }
+        //                //            break;
+        //                //        }
+        //                //    //变长
+        //                //    default:
+        //                //        {
+        //                //            //获取变长长度
+        //                //            Int32 tmpLen = Convert.ToInt32(MsgBitMap.BitMap[i, 0]);
+        //                //            //初始化字节数组
+        //                //            byte[] tmpData = new byte[tmpLen];
+        //                //            //取得当前域字节数据
+        //                //            for (int n = 0; n < tmpLen; n++)
+        //                //            {
+        //                //                tmpData[n] = data[curPosition + n];
+        //                //            }
+        //                //            //新位置
+        //                //            curPosition = curPosition + tmpLen;
+
+        //                //            tmpLen = Convert.ToInt32(CommomFunctions.NVL(PlatformSettings.Encoding.GetString(tmpData), 0));
+        //                //            //初始化字节数组
+        //                //            tmpData = new byte[tmpLen];
+        //                //            //取得当前域字节数据
+        //                //            for (int m = 0; m < tmpLen; m++)
+        //                //            {
+        //                //                tmpData[m] = data[curPosition + m];
+        //                //            }
+        //                //            //新位置
+        //                //            curPosition = curPosition + tmpLen;
+
+        //                //            //无子域))
+        //                //            if (MsgBitMap.BitMap[i, 3] == "0")
+        //                //            {
+        //                //                tmpMsg.GetType().GetProperty(tmpStr01).SetValue(tmpMsg,
+        //                //                                                             Encoding.GetEncoding(
+        //                //                                                                 CommonParames.Coding).GetString(
+        //                //                                                                     tmpData), null);
+        //                //                //日志信息
+        //                //                logStr.Append(tmpStr01 + ":[" + Encoding.GetEncoding(
+        //                //                    CommonParames.Coding).GetString(
+        //                //                        tmpData) + "]\n");
+        //                //            }
+        //                //            //有子域
+        //                //            else if (MsgBitMap.BitMap[i, 3] == "1")
+        //                //            {
+        //                //                //取得0子域的数据
+        //                //                string tmpStr01Sub0 = tmpStr01 + "_" + "".PadLeft(2, '0');
+        //                //                tmpMsg.GetType().GetProperty(tmpStr01Sub0).SetValue(tmpMsg,
+        //                //                                                             Encoding.GetEncoding(
+        //                //                                                                 CommonParames.Coding).GetString(
+        //                //                                                                     tmpData), null);
+        //                //                //日志信息
+        //                //                logStr.Append(tmpStr01Sub0 + ":[" + Encoding.GetEncoding(
+        //                //                    CommonParames.Coding).GetString(
+        //                //                        tmpData) + "]\n");
+
+        //                //                Int64 tempPosition = 0;
+        //                //                bitMap = (string[,])msgBitMap.GetType().GetField(tmpStr02).GetValue(tmpStr02);
+        //                //                for (int j = 0; j < (bitMap.Length / 3); j++)
+        //                //                {
+        //                //                    //定长
+        //                //                    if (bitMap[j, 0] == "0")
+        //                //                    {
+        //                //                        //取得当前子域的数据
+        //                //                        string tmpStr01Sub = tmpStr01 + "_" + (j + 1).ToString().PadLeft(2, '0');
+
+        //                //                        byte[] tmpCurData = new byte[Convert.ToInt64(bitMap[j, 1])];
+        //                //                        //当前域数据长度不够定长子域的长度时执行
+        //                //                        if ((tmpData.Length - tempPosition) < tmpCurData.Length)
+        //                //                        {
+        //                //                            break;
+        //                //                        }
+        //                //                        Array.Copy(tmpData, tempPosition, tmpCurData, 0,
+        //                //                                   Convert.ToInt64(bitMap[j, 1]));
+        //                //                        //给对应子域赋值
+        //                //                        tmpMsg.GetType().GetProperty(tmpStr01Sub).SetValue(tmpMsg,
+        //                //                                                                     Encoding.GetEncoding(
+        //                //                                                                         CommonParames.Coding).
+        //                //                                                                         GetString(tmpCurData), null);
+        //                //                        //日志信息
+        //                //                        logStr.Append(tmpStr01Sub + ":[" + Encoding.GetEncoding(
+        //                //                                                                         CommonParames.Coding).
+        //                //                                                                         GetString(tmpCurData) + "]\n");
+
+        //                //                        tempPosition += Convert.ToInt64(bitMap[j, 1]);
+        //                //                    }
+        //                //                    //目前子域不允许为变长类型，程序暂不处理子域为变长情况。
+        //                //                    else
+        //                //                    {
+        //                //                    }
+        //                //                }
+        //                //            }
+        //                //            break;
+        //                //        }
+        //                //}
+        //                #endregion
+
+        //                #region 新的处理方案
+        //                var fdName = (i + 1).ToString().PadLeft(3, '0') + "0";
+        //                if (!MsgBitMap.Instance.FdBitMap.ContainsKey(fdName))
+        //                {
+        //                    continue;
+        //                }
+        //                var item = MsgBitMap.Instance.FdBitMap[fdName];
+        //                switch (item.FieldType)
+        //                {
+        //                    case "-1":
+        //                        {
+        //                            break;
+        //                        }
+        //                    case "0":
+        //                        {
+        //                            //定长域
+        //                            var tmp = new byte[item.Length];
+        //                            //截取数据区域，判定新位置
+        //                            Array.Copy(data, curPosition, tmp, 0, tmp.Length);
+        //                            curPosition = curPosition + tmp.Length;
+
+        //                            if (item.Children == null || item.Children.Count == 0)
+        //                            {
+        //                                tmpMsg.SetFdValue(item.Code, PlatformSettings.Encoding.GetString(tmp));
+        //                            }
+        //                            else
+        //                            {
+        //                                //循环给子域赋值，子域暂时只存在定长域
+        //                                int index = 0;
+        //                                foreach (var child in item.Children)
+        //                                {
+        //                                    //子域为定长
+        //                                    var childData = new byte[child.Length];
+        //                                    Array.Copy(tmp, index, childData, 0, childData.Length);
+        //                                    index += childData.Length;
+        //                                    tmpMsg.SetFdValue(child.Code, PlatformSettings.Encoding.GetString(childData));
+        //                                }
+        //                            }
+        //                            break;
+        //                        }
+        //                    default:
+        //                        {
+        //                            //变长域
+        //                            //获取数据长度
+        //                            var len = int.Parse(item.FieldType);
+        //                            var tmp = new byte[len];
+        //                            Array.Copy(data, curPosition, tmp, 0, tmp.Length);
+        //                            curPosition = curPosition + tmp.Length;
+        //                            //获取数据部分
+        //                            var length = int.Parse(PlatformSettings.Encoding.GetString(tmp));
+        //                            tmp = new byte[length];
+        //                            Array.Copy(data, curPosition, tmp, 0, tmp.Length);
+        //                            curPosition = curPosition + tmp.Length;
+
+        //                            if (item.Children == null || item.Children.Count == 0)
+        //                            {
+        //                                tmpMsg.SetFdValue(item.Code, PlatformSettings.Encoding.GetString(tmp));
+        //                            }
+        //                            else
+        //                            {
+        //                                //循环给子域赋值，子域暂时只存在定长域
+        //                                int index = 0;
+        //                                foreach (var child in item.Children)
+        //                                {
+        //                                    //子域为定长
+        //                                    var childData = new byte[child.Length];
+        //                                    Array.Copy(tmp, index, childData, 0, childData.Length);
+        //                                    index += childData.Length;
+        //                                    tmpMsg.SetFdValue(child.Code, PlatformSettings.Encoding.GetString(childData));
+        //                                }
+        //                            }
+        //                            break;
+        //                        }
+        //                }
+        //                #endregion
+        //            }
+        //        }
+        //    }
+        //    catch (Exception)
+        //    {
+        //        //解包出错时将已经解析的数据域写入交易日志文件
+        //        //MsgPackage.LogObj.Info("\n应答数据:\n" + logStr.ToString());
+        //        PlatformLogger.CommunicationInfo("\n应答数据:\n" + logStr.ToString());
+        //        throw;
+        //    }
+        //    //解包完成后将解析数据写入交易日志文件
+        //    //MsgPackage.LogObj.Info("\n应答数据:\n" + logStr.ToString());
+        //    PlatformLogger.CommunicationInfo("\n应答数据:\n" + logStr.ToString());
+        //    return tmpMsg;
+        //}
+        #endregion
+        #endregion
+
+    }
+
+}

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

@@ -0,0 +1,427 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Platform.Common;
+using Platform.Common.RunningParameters;
+using Platform.Common.LogSystem;
+
+namespace TellerSystem.Communication.Package
+{
+    /// <summary>
+    /// 8583 128域类型报文，Tcp通讯方式的组包，解包处理。承德Tips
+    /// </summary>
+    class Msg858304 : IPackage
+    {
+        //定义静态实例
+        public static Msg858304 Instance;
+        /// <summary>
+        ///静态实例初始化函数
+        /// </summary>
+        static public Msg858304 GetInstance()
+        {
+            if (Instance == null)
+            {
+                Instance = new Msg858304();
+            }
+            return Instance;
+        }
+
+        /// <summary>
+        /// 组包操作
+        /// </summary>
+        /// <returns>报文数据包</returns>
+        public byte[] Integrate(Message msg)
+        {
+            byte[] returnData = null;
+
+            try
+            {
+                returnData = DoIntegrate(msg);
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("组包发生异常：", ex);
+                throw;
+            }
+            return returnData;
+        }
+
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg">核心返回数据包</param>
+        /// <param name="data">核心返回数据包</param>
+        /// <returns></returns>
+        public bool Analyze(Message msg, byte[] data)
+        {
+            try
+            {
+                //进行解包处理
+                DoAnalyze(msg, data);
+            }
+            catch (Exception ex)
+            {
+
+                return false;
+            }
+            return true;
+        }
+
+        #region 组包处理
+
+        /// <summary>
+        /// 组包处理
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <returns></returns>
+        private byte[] DoIntegrate(Message msg)
+        {
+            #region new
+            ///*******************************************
+            // * 组包规则：
+            // * msgHeader         byte[68]   Tuxedo报文头
+            // * msgData           byte[]     报文数据
+            // * fileFlag          byte       是否发送附件 
+            // * *****************************************/
+
+            ////文件标志
+            //byte fileFlag = (byte)(msg.FileFlag ? 0x7f : 0xff);
+            ////报文数据
+            //byte[] bitMapData;
+            //var fdData = msg.IntegrateFd(out bitMapData);
+            //byte[] msgKindData = PlatformSettings.Encoding.GetBytes(MsgParames.MsgType.PadLeft(5, '0'));
+            //var msgData = new byte[msgKindData.Length + bitMapData.Length + fdData.Length];
+            //msgKindData.CopyTo(msgData, 0);
+            //bitMapData.CopyTo(msgData, msgKindData.Length);
+            //fdData.CopyTo(msgData, msgKindData.Length + bitMapData.Length);
+            ////加密报文数据
+            //MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(MsgParames.KeyStr), 1);
+            ////报文头
+            //var msgHeader = GetMsgT(msg, msgData.Length.ToString()).ToArray<byte>();
+            ////组装报文
+            //var totalData = new byte[msgHeader.Length + msgData.Length + 1];
+            //msgHeader.CopyTo(totalData, 0);
+            //msgData.CopyTo(totalData, msgHeader.Length);
+            //totalData[totalData.Length - 1] = fileFlag;
+
+            //return totalData;
+            #endregion
+
+
+            #region deleted
+            //报文数据区
+            byte[] msgData;
+            //报文总长度
+            int totalLen;
+            //8位长度对应字符串
+            string strLen;
+            //报文数据区的长度
+            int msgDataLen;
+            //60位报文头
+            string msgTitle;
+            //5报文类型
+            byte[] msgKindByte;
+            //位图区域
+            byte[] bitMapByte = new byte[16];
+            //有效数据内容
+            string bitDataStr = string.Empty;
+            byte[] bitDataByte;
+            //组包数据包
+            byte[] totalMsgData;
+
+            //文件标志 0xff==no file   0x7f==file
+            byte fileFlag;
+            //根据当前交易附件标志设置文件标志
+            if (msg.FileFlag)
+            {
+                fileFlag = 0x7f;
+            }
+            //无文件
+            else
+            {
+                fileFlag = 0xff;
+            }
+            try
+            {
+                //报文类型
+                msgKindByte = PlatformSettings.Encoding.GetBytes("00000");
+                //组织报文数据区域信息，位图区，数据区
+                //GetBitData(msg, bitMapByte, ref bitDataStr);
+                //bitDataByte = PlatformSettings.Encoding.GetBytes(bitDataStr);
+                bitDataByte = msg.IntegrateFd(out bitMapByte);
+
+                //报文数据区长度
+                msgDataLen = msgKindByte.Length + bitMapByte.Length + bitDataByte.Length;
+                //报文总长度
+                totalLen = msgDataLen + 60;
+                //8位长度对应字符串
+                strLen = Convert.ToString(totalLen).PadLeft(8, '0');
+                //60位报文头
+                msgTitle = msgDataLen.ToString().PadLeft(4, '0').PadLeft(60, ' ');//GetMsgT(msg, msgDataLen.ToString());
+
+                //合并5位报文类型，位图，数据区域
+                msgData = new byte[msgDataLen];
+                //合并操作
+                for (int i = 0; i < msgData.Length; i++)
+                {
+                    if (i < msgKindByte.Length)
+                    {
+                        msgData[i] = msgKindByte[i];
+                    }
+
+                    if (i > msgKindByte.Length - 1 & i < msgKindByte.Length + bitMapByte.Length)
+                    {
+                        msgData[i] = bitMapByte[i - msgKindByte.Length];
+                    }
+                    if (i > msgKindByte.Length + bitMapByte.Length - 1)
+                    {
+                        msgData[i] = bitDataByte[i - msgKindByte.Length - bitMapByte.Length];
+                    }
+                }
+
+                //MsgPackage.LogObj.Debug("加密前数据："+PlatformSettings.Encoding.GetString(msgData));
+                //加密报文数据区
+                //MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(CommonSettings.KeyStr), 1);
+                //MsgPackage.LogObj.Debug("加密后数据：" + PlatformSettings.Encoding.GetString(msgData));
+
+                //合并组包数据
+                //8位的报文长度
+                byte[] len8 = PlatformSettings.Encoding.GetBytes(strLen);//new byte[0];
+                //报文头字节数组
+                byte[] msgTitleByte = PlatformSettings.Encoding.GetBytes(msgTitle);
+                totalMsgData = new byte[len8.Length + msgTitleByte.Length + msgData.Length + 1];
+                for (int j = 0; j < totalMsgData.Length - 1; j++)
+                {
+                    if (j < len8.Length)
+                    {
+                        totalMsgData[j] = len8[j];
+                    }
+                    if (j > len8.Length - 1 & j < len8.Length + msgTitleByte.Length)
+                    {
+                        totalMsgData[j] = msgTitleByte[j - len8.Length];
+                    }
+                    if (j > len8.Length + msgTitleByte.Length - 1)
+                    {
+                        totalMsgData[j] = msgData[j - len8.Length - msgTitleByte.Length];
+                    }
+                }
+                //设置文件标志位
+                totalMsgData[totalMsgData.Length - 1] = fileFlag;
+
+                //处理附件
+                if (msg.FileFlag)
+                {
+                    //文件追加到数据后
+                    var file = PlatformSettings.Encoding.GetBytes(msg.FileData);
+                    var lenData = PlatformSettings.Encoding.GetBytes(file.Length.ToString().PadLeft(8, '0'));
+                    var fileName = PlatformSettings.Encoding.GetBytes((LoginUserInfo.KinbrNo + LoginUserInfo.TtyName).PadRight(30));
+                    var ret = new byte[totalMsgData.Length + fileName.Length + lenData.Length + file.Length + 1];
+                    Array.Copy(totalMsgData, ret, totalMsgData.Length);
+                    Array.Copy(fileName, 0, ret, totalMsgData.Length, fileName.Length);
+                    Array.Copy(lenData, 0, ret, totalMsgData.Length + fileName.Length, lenData.Length);
+                    Array.Copy(file, 0, ret, totalMsgData.Length + fileName.Length + lenData.Length, file.Length);
+                    //补充一个结束字符
+                    ret[ret.Length - 1] = 0xff;
+                    totalMsgData = ret;
+                }
+                //MsgPackage.LogObj.Debug("报文整体数据：" + PlatformSettings.Encoding.GetString(totalMsgData));
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("组包发生异常！", ex);
+                throw;
+            }
+            return totalMsgData;
+            #endregion
+        }
+
+        /// <summary>
+        /// 生成TUXEDO方式报文头
+        /// </summary>
+        /// <param name="msg">域信息</param>
+        /// <param name="msgDataLen"></param>
+        /// <returns></returns>
+        private string GetMsgT(Message msg, string msgDataLen)
+        {
+            string clnm = "";                 //5位   空串
+            string svcnm = "";                //15位  Tuxedo交易服务名
+            string reqtype = "";              //1位   "4"
+            string branchNo = "";             //5位   机构编号
+            string tty = "";                  //9位   终端号
+            string titaOr8583;                //1位   代码中的值 8’
+            string cbs = "";                  //10位  空串
+            string macflg = "";               //1位   空串
+            string mac = "";                  //8位   空串
+            string result = "";               //1位   '0'
+            string len = "";                  //4位   8583数据区长度
+            //TUXEDO方式报文头
+            StringBuilder tmpMstTile = new StringBuilder();
+
+            //设置对应变量的值
+            clnm = "".PadLeft(5, ' ');
+            tmpMstTile.Append(clnm);
+            svcnm = "".PadLeft(15, ' ');
+            tmpMstTile.Append(svcnm);
+            reqtype = "4";
+            tmpMstTile.Append(reqtype);
+            //TODO:机构号扩展为10位，故报文大小变成68
+            branchNo = msg.Fd3.PadLeft(10, ' ');
+            tmpMstTile.Append(branchNo);
+            //TODO:由于tty采用12位，故修改为12位（保证核心已经修改）
+            //tty = msg.Fd10.PadLeft(9, ' ');
+            tty = msg.Fd10.PadLeft(12, ' ');
+            tmpMstTile.Append(tty);
+            titaOr8583 = "8";
+            tmpMstTile.Append(titaOr8583);
+            cbs = "".PadLeft(10, ' ');
+            tmpMstTile.Append(cbs);
+            macflg = "".PadLeft(1, ' ');
+            tmpMstTile.Append(macflg);
+            mac = "".PadLeft(8, ' ');
+            tmpMstTile.Append(mac);
+            result = "0";
+            tmpMstTile.Append(result);
+            len = msgDataLen.PadLeft(4, '0');
+            tmpMstTile.Append(len);
+
+            return tmpMstTile.ToString();
+        }
+        #endregion
+
+        #region 解包处理
+
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <param name="returnData"></param>
+        /// <returns></returns>
+        public void DoAnalyze(Message msg, byte[] returnData)
+        {
+            try
+            {
+                //丢弃前8位
+                var ret = new byte[returnData.Length - 8];
+                Array.Copy(returnData, 8, ret, 0, ret.Length);
+                returnData = ret;
+
+                //报文前68位内容       
+                byte[] msg60 = new byte[60];
+                //报文数据区长度        
+                int msgDataLen = 0;
+                //报文数据区内容
+                byte[] msgData;
+                //报文有效数据内容
+                byte[] msgDataReal;
+                //报文位图区
+                byte[] msgBit;
+                string msgBitStr = "";
+
+                //报文前60位（60位报文头）
+                for (int i = 0; i < 60; i++)
+                {
+                    msg60[i] = returnData[i];
+                }
+
+                //报文数据区长度 
+                byte[] tmpLen = new byte[4];
+                Array.Copy(msg60, 56, tmpLen, 0, 4);
+                msgDataLen = Convert.ToInt32(PlatformSettings.Encoding.GetString(tmpLen));
+
+                //报文前60位字符串内容
+                //MsgStr60 = Encoding.GetEncoding(CAppInfo.CodingStr).GetString(Msg60);
+
+                //返回数据中的长度没有去掉报文头的长度，在此去掉--huanghuaxun
+                if (msgDataLen > 68)
+                    msgDataLen -= 68;
+                #region 20140423 王全
+                //承德平台无此返回报文场景
+                ////如果报文数据区第五位为0xff
+                ////总共报文数据区为4位应答码.
+                //if (returnData[72] == (byte)'\0')
+                //{
+                //    //应答码错误信息
+                //    byte[] tmpData = new byte[4];
+                //    //取得应答码错误信息内容
+                //    Array.Copy(returnData, 68, tmpData, 0, 4);
+                //    //返回应答码
+                //    msg.Fd12 = PlatformSettings.Encoding.GetString(tmpData);
+                //    return;
+                //}
+                #endregion
+
+                //取得报文数据区内容
+                msgData = new byte[msgDataLen];
+                Array.Copy(returnData, 60, msgData, 0, msgDataLen);
+                //文件标志
+                byte fileDataFlag = returnData[20];
+                //解密数据区内容
+                //MsgPackage.Encrypt(msgData, Encoding.ASCII.GetBytes(CommonSettings.KeyStr),
+                //                   0);
+                #region delete 解包封装
+                ////报文数据区格式为 5位报文类型+16位位图区域+有效数据区
+                ////报文位图区
+                ////报文位图区存在2种情况，当位图区第1域为0时，位图长度为64（压缩为8位数据），否则为128（压缩为16位数据）
+                ////标志位，是否采用128位位图
+                //bool IsBitmap128 = Convert.ToString(msgData[5], 2).PadLeft(8, '0').StartsWith("1");
+
+                //msgBit = new byte[IsBitmap128 ? 16 : 8];
+                //Array.Copy(msgData, 5, msgBit, 0, msgBit.Length);
+                ////扩展16位字符串转换为128位01格式的位图字符串
+                //foreach (byte bytes in msgBit)
+                //{
+                //    msgBitStr += Convert.ToString(bytes, 2).PadLeft(8, '0');
+                //}
+                ////写调试日志
+                ////MsgPackage.LogObj.Debug("\n返回位图:\n" + msgBitStr.Replace('\0', '\n'));
+                ////报文数据内容
+                //int startIndex = 5 + (IsBitmap128 ? 16 : 8);
+                //msgDataReal = new byte[msgDataLen - startIndex];
+                //Array.Copy(msgData, startIndex, msgDataReal, 0, msgDataReal.Length);
+                ////写调试日志
+                ////MsgPackage.LogObj.Debug("\n解包前应答数据:\n" + PlatformSettings.Encoding.GetString(msgDataReal).Replace('\0', '\n'));
+
+                ////详细解析每个域的信息
+                ////Message tmpMsg = AnilyzeFd(msgBitStr, msgDataReal, msg);
+                //if (!msg.AnilyzeFd(msgBitStr, msgDataReal))
+                //{
+                //    //解包失败
+                //    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
+                //}
+                if (!msg.AnilyzeFd(msgData))
+                {
+                    //解包失败
+                    throw new FormatException("8583通讯解包操作失败！具体情况请查看日志！");
+                }
+                #endregion
+                //将解析后结果复制到当前交易对象中
+                //MsgPackage.Clone(msg, tmpMsg);
+                //有文件附件的处理
+                //存在附件，规则[文件名称:30][数据长度:8][数据:n]
+                var fileLen = returnData.Length - 68 - msgDataLen - 38 - 1;
+                if (fileLen > 0)
+                {
+                    //报文文件内容               
+                    byte[] fileData = new byte[fileLen];
+                    //加8位数据长度
+                    Array.Copy(returnData, 68 + msgDataLen + 38 + 1, fileData, 0, fileLen);
+                    //返回解包后文件数据
+                    msg.FileData = PlatformSettings.Encoding.GetString(fileData);
+                    //写调试日志
+                    PlatformLogger.CommunicationInfo("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
+                }
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("解析报文失败！", ex);
+                throw;
+            }
+        }
+        #endregion
+
+    }
+}

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

@@ -0,0 +1,355 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using Platform.Common;
+using Platform.ServiceProxy.ServiceHelper;
+using Platform.Common.RunningParameters;
+using Platform.Common.LogSystem;
+using TellerSystem.ServiceProxy.Ext;
+using TellerSystem.ServiceProxy.Ext.ServiceHelper;
+using System.Diagnostics;
+using TellerSystem.Communication.SocketListener;
+using System.IO;
+
+namespace TellerSystem.Communication.Package
+{
+    /// <summary>
+    /// 交易处理相关操作
+    /// </summary>
+    class MsgPackage
+    {
+        //报文处理接口对象
+        public static Dictionary<PackageType, IPackage> PackageList = new Dictionary<PackageType, IPackage>
+        {
+            {PackageType.Msg858301,Msg858301.GetInstance()},
+            {PackageType.Msg858302,Msg858302.GetInstance()},
+             {PackageType.Msg858304,Msg858304.GetInstance()},
+             {PackageType.MsgXml01,MsgXml01.GetInstance()}
+        };
+
+        /// <summary>
+        /// 交易处理
+        /// </summary>
+        /// <param name="msg">报文对象</param>
+        /// <param name="transit">callserver,callagn,calltips</param>
+        /// <returns></returns>
+        public static bool Trade(Message msg, PackageType packageType, string transit)
+        {
+            //组包后数据
+            byte[] integrateData;
+            //交易整体数据
+            byte[] totalData;
+            //通讯返回数据
+            byte[] returnData;
+            byte[] fileData = new byte[0];
+            bool retunValue = false;
+
+            //根据当前报文类型实例化报文处理对象
+            if (!PackageList.ContainsKey(packageType))
+            {
+                PlatformLogger.TradeErrorInfo("MsgPackage.Trade:不支持的报文类型！-->" + packageType.ToString(), null);
+                return false;
+            }
+            try
+            {
+                //根据当前报文类型实例化报文处理对象，
+                var package = PackageList[packageType];
+                //GetPackageInstance(transit);
+                //组包
+                integrateData = package.Integrate(msg);
+                //通讯
+                var fileName = msg.Fd3.Replace(" ", "") + msg.Fd10.Replace(" ", "");
+                Stopwatch watch = new Stopwatch();
+                watch.Start();
+                List<byte[]> list;
+                if (ServiceSettings.IsRecordPrintData)
+                {
+                    //登记通讯报文类型
+                    string msgType = msg.IsMainTrade ? packageType.ToString() : string.Empty;
+                    try
+                    {
+                        list = TradeHandle.DoTrade(transit, integrateData, msg.Fd3, fileName, PlatformSettings.Encoding.GetBytes(Message.Cconv(msg.FileData)), null, msg.SerialNumber, msgType);//生僻字转义：文件组包处理
+                    }
+                    catch { list = null; }
+                    //当主交易通讯情况，未返回数据，需要查询记录，尝试进行补偿
+                    if (msg.IsMainTrade && (list == null || list.Count == 0))
+                    {
+                        //考虑到网络波动，需尝试3次
+                        for (int i = 0; i < 3; i++)
+                        {
+                            try
+                            {
+                                var data = PrintManagerHandle.GetPrintExtDataById(msg.SerialNumber);
+                                if (data != null)
+                                {
+                                    PlatformLogger.SystemInfo("MsgPackage:主通讯补偿成功！" + msg.SerialNumber);
+                                    list = new List<byte[]> { data.Message };
+                                    if (data.MsgFile != null && data.MsgFile.Length > 0) list.Add(data.MsgFile);
+                                    break;
+                                }
+                            }
+                            catch (Exception ex) { PlatformLogger.SystemErrorInfo("MsgPackage:主通讯补偿失败！" + msg.SerialNumber, ex); }
+                            System.Threading.Thread.Sleep(200);
+                        }
+                        //登记入库
+                        TradeHandle.WriteImportantLog("主通讯触发补偿", msg.SerialNumber, ((list != null && list.Count > 0) ? "成功" : "失败"), "DoTrade", "2", string.Join(",", SocketManager.GetLocalIpAddressList()));
+                    }
+                }
+                else
+                {
+                    list = TradeHandle.DoTrade(transit, integrateData, msg.Fd3, fileName, PlatformSettings.Encoding.GetBytes(Message.Cconv(msg.FileData)), null, msg.SerialNumber);
+                }
+                watch.Stop();
+                if (watch.ElapsedMilliseconds > 2000)
+                    TradeHandle.WriteImportantLog("通讯时间统计", watch.ElapsedMilliseconds.ToString(), msg.Fd16, "DoTrade", "2", string.Join(",", SocketManager.GetLocalIpAddressList()));
+                //重置主交易标识
+                msg.IsMainTrade = false;
+                returnData = list[0];
+                //处理文件附件
+                if (list.Count > 1)
+                {
+                    fileData = list[1];
+                }
+                byte fileDataFlag = 0;
+                if (returnData != null && returnData.Length > 0)
+                {
+                    if (returnData.Length < 20)
+                        PlatformLogger.SystemErrorInfo(string.Format("MsgPackage:返回报文长度太短，无法获取附件标志！", returnData.Length), new Exception());
+                    fileDataFlag = returnData[20];
+                }
+                else
+                {
+                    //通讯出现异常，需要添加错误码
+                    msg.Fd12 = "COMM";
+                    return false;
+                }
+                //重置附件发送标志
+                msg.FileFlag = false;
+                totalData = new byte[returnData.Length + fileData.Length];
+                Array.Copy(returnData, 0, totalData, 0, returnData.Length);
+                Array.Copy(fileData, 0, totalData, returnData.Length, fileData.Length);
+                //解包
+                retunValue = package.Analyze(msg, totalData);
+
+
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("Trade: 函数出错. ", ex);
+                return false;
+            }
+            return retunValue;
+        }
+
+        #region 报文处理相关功能函数
+
+        /// <summary>
+        /// 加密，解密函数
+        /// 加密：flg=1    解密：flg=0
+        /// </summary>
+        /// <param name="myData"></param>
+        /// <param name="key"></param>
+        /// <param name="flg"></param>
+        /// <returns></returns>
+        public static bool Encrypt(byte[] myData, byte[] key, int flg)
+        {
+            //TODO:焦作项目不用做数据加密,暂时写死
+            if (true) return true;
+
+            int klen;
+            klen = key.Length;
+            string value;
+            try
+            {
+                for (int i = 0; i < myData.Length; i++)
+                {
+                    //加密
+                    if (flg == 1)
+                    {   //溢出情况           
+                        if ((myData[i] + key[i % klen]) > 255)
+                        {
+                            value = Convert.ToString((myData[i]) + key[i % klen], 2);
+                            myData[i] = Convert.ToByte(Convert.ToInt32(value.Substring(value.Length - 8, 8), 2));
+                        }
+                        //正常情况
+                        else
+                        {
+                            myData[i] = Convert.ToByte(myData[i] + key[i % klen]);
+                        }
+                    }
+                    //解密
+                    else
+                    {
+                        //溢出情况
+                        if (myData[i] < key[i % klen])
+                        {
+                            value = Convert.ToString((myData[i]), 2).PadLeft(8, '0');
+                            value = "1" + value;
+                            myData[i] = Convert.ToByte(Convert.ToInt32(value, 2) - key[i % klen]);
+                        }
+                        //正常情况
+                        else
+                        {
+                            myData[i] = Convert.ToByte(myData[i] - key[i % klen]);
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("加密解密出错！", ex);
+                throw;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 复制对象的属性值
+        /// </summary>
+        /// <param name="obj">复制目标对象</param>
+        /// <param name="source">复制源对象</param>
+        public static void Clone(Message obj, Message source)
+        {
+            System.Reflection.PropertyInfo[] tmp = obj.GetType().GetProperties();
+
+            //复制所有的属性
+            for (int i = 0; i < tmp.Length; i++)
+            {
+                tmp[i].SetValue(obj, tmp[i].GetValue(source, null), null);
+            }
+            //复制所有的filed
+        }
+
+
+        /// <summary>
+        /// 字节数组修复为GDK编码规则
+        /// </summary>
+        /// <param name="data"></param>
+        public static void CheckByte(byte[] data)
+        {
+            byte[] tmpData = null;
+            string tmpStr = string.Empty;
+            if (data == null || data.Length == 0)
+                return;
+            for (int i = 0; i < data.Length; i++)
+            {
+                //如果是ascii码字符,直接跳过 
+                if (data[i] < 128)
+                    continue;
+                //added by liuyong 2010-4-16 start
+                else
+                {
+                    if ((i + 1) >= data.Length)
+                        continue;
+                    tmpData = new byte[2];
+                    tmpData[0] = data[i];
+                    tmpData[1] = data[i + 1];
+
+                    tmpStr = PlatformSettings.Encoding.GetString(tmpData);
+                    //全角字符且不是汉字则不进行转换
+                    if (IsSbc(tmpStr) && !IsChinese(tmpStr))
+                    {
+                        i++;
+                        continue;
+                    }
+                }
+                //added by liuyong 2010-4-16 end
+                if (data[i] >= 0x81 && data[i] <= 0xa0)//GBK/3高位区间 129-160
+                {
+                    if ((i + 1) >= data.Length)
+                        continue;
+                    if (data[i + 1] < 0x40 || data[i + 1] > 0xfe)  //64 254
+                    {
+                        data[i] = 61;
+                        continue;
+                    }
+                    i++;
+                }
+                else if (data[i] >= 0xa1 && data[i] <= 0xa9)//GBK/1 高位区间 161-169
+                {
+                    if ((i + 1) >= data.Length)
+                        continue;
+                    if (data[i + 1] < 0xa1 || data[i + 1] > 0xef)  //161 239
+                    {
+                        data[i] = 61;
+                        continue;
+                    }
+                    i++;
+                }
+                else if (data[i] >= 0xaa && data[i] <= 0xfe)//GBK/4高位区间  170-254
+                {
+                    if ((i + 1) >= data.Length)
+                        continue;
+                    if (data[i + 1] < 0x40) //64
+                    {
+                        data[i] = 61;
+                        continue;
+                    }
+                    else if (data[i + 1] > 0xa0) //160
+                    {
+                        //GBK/2高位区间
+                        if ((data[i] >= 0xb0 && data[i] <= 0xf7)) //176-247
+                        {
+                            //低位错误，证明是随机字符，高低位同时修复161 254
+                            if (data[i + 1] < 0xa1 || data[i + 1] > 0xfe)
+                            {
+                                data[i] = 61;
+                                continue;
+                            }
+                        }
+                    }
+                    i++;
+                }
+                else //错误乱码直接修复
+                {
+                    data[i] = 61;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 判断字符串是否是全角字符
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        private static bool IsSbc(string str)
+        {
+            bool blRet = false;
+            if (2 * str.Length == Encoding.Default.GetByteCount(str))
+            {
+                blRet = true;
+            }
+            else
+            {
+                blRet = false;
+            }
+            return blRet;
+        }
+
+        /// <summary>
+        /// 判断是否为中文
+        /// </summary>
+        /// <param name="word"></param>
+        /// <returns></returns>
+        private static bool IsChinese(string word)
+        {
+            Regex rx = null;
+            if (string.IsNullOrEmpty(word))
+                return false;
+
+            rx = new Regex("^[\u4e00-\u9fa5]$");
+
+            if (rx.IsMatch(word))
+                return true;
+            else
+                return false;
+        }
+
+        #endregion
+
+    }
+}

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

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Platform.Common.RunningParameters;
+using Platform.Common.LogSystem;
+using System.Xml;
+using System.IO;
+
+namespace TellerSystem.Communication.Package
+{
+    class MsgXml01 : IPackage
+    {
+        //定义静态实例
+        public static MsgXml01 Instance;
+        /// <summary>
+        ///静态实例初始化函数
+        /// </summary>
+        static public MsgXml01 GetInstance()
+        {
+            if (Instance == null)
+            {
+                Instance = new MsgXml01();
+            }
+            return Instance;
+        }
+
+        public byte[] Integrate(Message msg)
+        {
+            //整个发送包的byte数组，是下面两个的总和，= 8位 + 报文体
+            byte[] totalMsgData;
+            //8位报文体长度的byte数组
+            byte[] dataPartLength;
+            //报文体的byte数组
+            byte[] dataPart;
+            try
+            {
+                string xmlFirstLine = "<?xml version=\"1.0\" encoding=\"GBK\"?>";
+                string upTagBegin = "<service>";
+                string xmlHeader = Msg8583ToHeader(msg);
+                string xmlData = msg.FileData;
+                string upTagEnd = "</service>";
+                //报文体（string类型）
+                string dataPartStr = xmlFirstLine + upTagBegin + xmlHeader + xmlData + upTagEnd;
+                dataPart = PlatformSettings.Encoding.GetBytes(dataPartStr);
+                //报文体长度（Int类型）
+                int dataPartLengthInt = dataPart.Length;
+                //报文体长度（string类型，且左边用0补齐8位）
+                string dataPartLengthStr = dataPartLengthInt.ToString().PadLeft(8, '0');
+                dataPartLength = PlatformSettings.Encoding.GetBytes(dataPartLengthStr);
+                totalMsgData = new byte[8 + dataPartLengthInt];
+                for (int j = 0; j < totalMsgData.Length; j++)
+                {
+                    if (j < 8)
+                    {
+                        totalMsgData[j] = dataPartLength[j];
+                    }
+                    else
+                    {
+                        totalMsgData[j] = dataPart[j - 8];
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                PlatformLogger.SystemErrorInfo("组包发生异常！", ex);
+                throw;
+            }
+
+            return totalMsgData;
+        }
+
+        private string Msg8583ToHeader(Message msg)
+        {
+            var result = new StringBuilder();
+            result.Append("<SysHead>");
+            //交易码
+            result.Append(string.Format("<Txcode>{0}</Txcode>", msg.Fd16.Trim()));
+            //前台流水
+            result.Append(string.Format("<FrontTrace>{0}</FrontTrace>", msg.Fd96_Q.Trim()));
+            //交易日期
+            result.Append(string.Format("<Txdate>{0}</Txdate>", msg.Fd5.Trim()));
+            //交易时间
+            result.Append(string.Format("<Txtime>{0}</Txtime>", msg.Fd6.Trim()));
+            //机构编号
+            result.Append(string.Format("<InstNo>{0}</InstNo>", msg.Fd2.Trim()));
+            //柜员号
+            result.Append(string.Format("<UserNo>{0}</UserNo>", msg.Fd7.Trim()));
+            
+            result.Append("</SysHead>");
+            return result.ToString();
+        }
+
+        public bool Analyze(Message msg, byte[] data)
+        {
+            try
+            {
+                //进行解包处理
+                DoAnalyze(msg, data);
+            }
+            catch (Exception ex)
+            {
+                return false;
+            }
+            return true;
+        }
+        /// <summary>
+        /// 解包操作
+        /// </summary>
+        /// <param name="msg"></param>
+        /// <param name="returnData"></param>
+        /// <returns></returns>
+        public void DoAnalyze(Message msg, byte[] returnData)
+        {
+            try
+            {
+                //报文XML区长度        
+                int xmlDataLen = 0;
+                //报文数据区长度 
+                byte[] tmpLen = new byte[8];
+                Array.Copy(returnData, 0, tmpLen, 0, 8);
+                xmlDataLen = Convert.ToInt32(PlatformSettings.Encoding.GetString(tmpLen));
+
+                //丢弃前8位
+                var ret = new byte[xmlDataLen];
+                Array.Copy(returnData, 8, ret, 0, xmlDataLen);
+                returnData = ret;
+                XmlDocument doc = new XmlDocument();
+                string xmlStr=PlatformSettings.Encoding.GetString(returnData);
+                //日志
+                PlatformLogger.CommunicationInfo("\n返回报文数据:\n" + xmlStr);
+
+                doc.LoadXml(xmlStr);
+                var node = doc.SelectSingleNode("/service/SysHead");
+                msg.Fd16 = node.ChildNodes[0].InnerText;
+                msg.Fd5 = node.ChildNodes[1].InnerText;
+                msg.Fd6 = node.ChildNodes[2].InnerText;
+                msg.Fd2 = node.ChildNodes[3].InnerText;
+                msg.Fd7 = node.ChildNodes[4].InnerText;
+
+                msg.Fd12 = node.ChildNodes[5].InnerText;
+                //msg.Fd13 = node.ChildNodes[6].InnerText;
+                var nodeOfBody=doc.SelectSingleNode("/service/Body");
+                if(nodeOfBody != null)
+                msg.FileData = doc.SelectSingleNode("/service/Body").OuterXml;
+                //var fileLen = returnData.Length - 8 - xmlDataLen ;
+                //if (fileLen > 0)
+                //{
+                //    byte[] fileData = new byte[fileLen];
+                //    Array.Copy(returnData, 8 + xmlDataLen, fileData, 0, fileLen);
+                //    //返回解包后文件数据
+                //    msg.FileData = PlatformSettings.Encoding.GetString(fileData);
+                //    //写调试日志
+                //    PlatformLogger.CommunicationInfo("\n文件数据:\n" + PlatformSettings.Encoding.GetString(fileData));
+                //}
+            }
+            catch (Exception ex)
+            {
+                //写错误信息
+                PlatformLogger.SystemErrorInfo("解析报文失败！", ex);
+                throw;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TellerSystem.Communication.Package
+{
+    /// <summary>
+    /// 支持的报文组装方式
+    /// </summary>
+    public enum PackageOptions
+    {
+        /// <summary>
+        /// 客户端组组解包 
+        /// </summary>
+        PackageOnClient,
+        /// <summary>
+        /// 服务端组组解包 
+        /// </summary>
+        PackageOnServer
+    }
+}

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

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace TellerSystem.Communication.Package
+{
+    /// <summary>
+    /// 支持的报文组装类型
+    /// </summary>
+    public enum PackageType
+    {
+        /// <summary>
+        ///  使用858301报文
+        /// </summary>
+        Msg858301,
+        /// <summary>
+        ///  使用858302报文
+        /// </summary>
+        Msg858302,
+        /// <summary>
+        /// 使用858304报文
+        /// </summary>
+        Msg858304,
+        /// <summary>
+        /// 反假币xml报文
+        /// </summary>
+        MsgXml01,
+    }
+}

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

@@ -0,0 +1,186 @@
+/*----------------------------------------------------------------------------------------------
+ 
+       Copyright (C) DHCC 版权所有
+
+       系统名:
+       类  名:  BufferManager
+       概  要: 
+       创建者:  Hu Ha
+       创建日:  01/18/2010 17:13:01
+       履  历:    No.        日期           Ver.No        修改人             描述																																																																										
+
+------------------------------------------------------------------------------------------------*/
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TellerSystem.Communication.SocketListener
+{
+    /// <summary>
+    /// 提供接收和发送缓冲区的管理
+    /// </summary>
+    public sealed class BufferManager
+    {
+        private byte[] m_receiveBuffer;
+        private byte[] m_sendBuffer;
+
+        private int m_maxRequest;
+        private int m_receiveBufferSize;
+        private int m_sendBufferSize;
+
+        private int m_bufferBlockIndex;
+        private Stack<int> m_bufferBlockIndexStack;
+
+        private static object Locker = new object();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BufferManager"/> class.
+        /// </summary>
+        /// <param name="maxRequest">The max request.</param>
+        /// <param name="receivevBufferSize">Size of the receivev buffer.</param>
+        /// <param name="sendBufferSize">Size of the send buffer.</param>
+        public BufferManager(int maxRequest, int receivevBufferSize, int sendBufferSize)
+        {
+            m_maxRequest = maxRequest;
+            m_receiveBufferSize = receivevBufferSize;
+            m_sendBufferSize = sendBufferSize;
+
+            m_bufferBlockIndex = 0;
+            m_bufferBlockIndexStack = new Stack<int>(maxRequest);
+
+            m_receiveBuffer = new byte[m_receiveBufferSize * m_maxRequest];
+            m_sendBuffer = new byte[m_sendBufferSize * m_maxRequest];
+        }
+
+        /// <summary>
+        /// 接收缓冲区总长度
+        /// </summary>
+        public int ReceiveBufferSize
+        {
+            get { return m_receiveBufferSize; }
+        }
+
+        /// <summary>
+        /// 发送缓冲区总长度
+        /// </summary>
+        public int SendBufferSize
+        {
+            get { return m_sendBufferSize; }
+        }
+
+        /// <summary>
+        /// 接收缓冲区
+        /// </summary>
+        public byte[] ReceiveBuffer
+        {
+            get { return m_receiveBuffer; }
+        }
+
+        /// <summary>
+        /// 发送缓冲区
+        /// </summary>
+        public byte[] SendBuffer
+        {
+            get { return m_sendBuffer; }
+        }
+
+        /// <summary>
+        /// 释放缓冲区索引
+        /// </summary>
+        /// <param name="bufferBlockIndex"></param>
+        public void FreeBufferBlockIndex(int bufferBlockIndex)
+        {
+            if (bufferBlockIndex >= this.m_maxRequest || bufferBlockIndex < 0)
+            {
+                return;
+            }
+
+            lock (Locker)
+            {
+                if (this.m_bufferBlockIndexStack.Contains(bufferBlockIndex))
+                    return;
+
+                m_bufferBlockIndexStack.Push(bufferBlockIndex);
+            }
+        }
+
+        /// <summary>
+        /// 获取缓冲区空闲的索引
+        /// </summary>
+        /// <returns></returns>
+        public int GetBufferBlockIndex()
+        {
+            lock (Locker)
+            {
+                int blockIndex = -1;
+
+                // 有用过释放的缓冲块
+                if (m_bufferBlockIndexStack.Count > 0)
+                {
+                    blockIndex = m_bufferBlockIndexStack.Pop();
+                }
+                else
+                {
+                    // 有未用缓冲区块
+                    if (m_bufferBlockIndex < m_maxRequest)
+                    {
+                        blockIndex = m_bufferBlockIndex++;
+                    }
+                }
+
+                return blockIndex;
+            }
+        }
+
+        /// <summary>
+        /// 获取接收缓冲区偏移量
+        /// </summary>
+        /// <param name="bufferBlockIndex">此接收缓冲区在整个缓冲区的索引</param>
+        /// <returns>接收缓冲区偏移量</returns>
+        public int GetReceiveBufferOffset(int bufferBlockIndex)
+        {
+            if (bufferBlockIndex >= this.m_maxRequest)
+            {
+                throw new ArgumentException(string.Format("索引超出最大请求数:{0}", this.m_maxRequest.ToString()));
+            }
+
+            if (bufferBlockIndex < 0)
+            {
+                return 0;
+            }
+
+            return bufferBlockIndex * m_receiveBufferSize;
+        }
+
+        /// <summary>
+        /// 获取发送缓冲区偏移量
+        /// </summary>
+        /// <param name="bufferBlockIndex">此发送缓冲区在整个缓冲区的索引</param>
+        /// <returns>发送缓冲区偏移量</returns>
+        public int GetSendBufferOffset(int bufferBlockIndex)
+        {
+            if (bufferBlockIndex >= this.m_maxRequest)
+            {
+                throw new ArgumentException(string.Format("索引超出最大请求数:{0}", this.m_maxRequest.ToString()));
+            }
+
+            if (bufferBlockIndex < 0)
+            {
+                return 0;
+            }
+
+            return bufferBlockIndex * m_sendBufferSize;
+        }
+
+        /// <summary>
+        /// 清理缓冲区
+        /// </summary>
+        public void Clear()
+        {
+            m_bufferBlockIndexStack.Clear();
+            m_receiveBuffer = null;
+            m_sendBuffer = null;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { ConfigManager } from './ConfigManager'
+import { ConfigType } from './ConfigType'
+
+/**
+ * 通讯设置类
+ */
+export class TransitSettings {
+    /**
+     * 通讯采用的加密方式
+     */
+    public static get KeyStr(): string {
+        return ConfigManager.getInstance().getConfigValue('KeyStr', ConfigType.System)
+    }
+}