platfrom common

ant-design-pro-vue3/src/views/front/platfrom/common/Base/IconBox.xaml

@@ -0,0 +1,22 @@
+<UserControl x:Class="Platform.Common.Base.IconBox"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:local="clr-namespace:Platform.Common.Base"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             Name="this"
+             d:DesignHeight="300"
+             d:DesignWidth="300"
+             mc:Ignorable="d">
+    <UserControl.Resources>
+        <Style x:Key="style_iconfont">
+            <Setter Property="TextBlock.FontFamily" Value="/Platform.Common;component/Base/#FontAwesome" />
+        </Style>
+    </UserControl.Resources>
+    <Viewbox>
+        <TextBlock FontSize="72"
+                   Style="{StaticResource style_iconfont}"
+                   Text="{Binding ElementName=this,
+                                  Path=Code}" />
+    </Viewbox>
+</UserControl>

ant-design-pro-vue3/src/views/front/platfrom/common/Base/IconBox.xaml.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace Platform.Common.Base
+{
+    /// <summary>
+    /// IconBox.xaml 的交互逻辑
+    /// </summary>
+    public partial class IconBox : UserControl
+    {
+        #region Ctor
+        public IconBox()
+        {
+            InitializeComponent();
+        }
+        #endregion
+
+        #region Code
+        /// <summary>
+        /// 图标字体的值
+        /// </summary>
+        public string Code
+        {
+            get { return (string)GetValue(CodeProperty); }
+            set { SetValue(CodeProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for Code.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty CodeProperty =
+            DependencyProperty.Register("Code", typeof(string), typeof(IconBox), new PropertyMetadata(""));
+        #endregion
+
+        #region Static
+        /// <summary>
+        /// 获取参数指定的图标画刷
+        /// </summary>
+        /// <param name="code"></param>
+        /// <returns></returns>
+        public static Brush GetIconBrush(string code, Brush foreground)
+        {
+            var icon = new IconBox();
+            icon.Code = code;
+            icon.Foreground = foreground;
+            return new VisualBrush(icon);
+        }
+
+        /// <summary>
+        /// 获取参数指定的图像源
+        /// </summary>
+        /// <param name="code"></param>
+        /// <param name="foreground"></param>
+        /// <returns></returns>
+        public static ImageSource GetIconSource(string code, Brush foreground)
+        {
+            var icon = new IconBox();
+            icon.Code = code;
+            icon.Foreground = foreground;
+            var window = new Window
+            {
+                Content = new ScrollViewer
+                {
+                    Content = icon,
+                    VerticalScrollBarVisibility = ScrollBarVisibility.Visible,
+                    HorizontalScrollBarVisibility = ScrollBarVisibility.Visible
+                },
+                SizeToContent = SizeToContent.WidthAndHeight
+            };
+            window.ShowInTaskbar = false;
+            window.WindowState = WindowState.Normal;
+            window.Top = 0 - 768;
+            window.Left = 0 - 1024;
+            window.Show();
+            window.Close();
+            //开始创建对象
+            var rtb = new RenderTargetBitmap((int)icon.ActualWidth, (int)icon.ActualHeight, 96, 96, PixelFormats.Pbgra32);
+            rtb.Render(icon);
+            return rtb;
+        }
+        #endregion
+
+        public enum IconType
+        {
+
+        }
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/AnimationsManager.ts

@@ -0,0 +1,38 @@
+// 假设 AnimationResource 是一个自定义的动画资源类型
+interface AnimationResource {
+  source: string;
+  // 可以根据实际需求添加更多属性
+}
+
+class AnimationsManager {
+  private static currentAnimation: AnimationResource | null = null;
+
+  /**
+   * 加载动画资源
+   * @param animation 动画资源对象
+   */
+  public static loadAnimation(animation: AnimationResource): void {
+    if (
+      !this.currentAnimation ||
+      this.currentAnimation.source !== animation.source
+    ) {
+      // 这里可以添加移除当前动画资源的逻辑，例如清理 DOM 中的动画元素等
+      this.currentAnimation = animation;
+      // 这里可以添加加载新动画资源的逻辑，例如动态引入 CSS 或 JS 文件等
+      console.log(`Loading animation from source: ${animation.source}`);
+    }
+  }
+
+  /**
+   * 根据 URI 加载动画资源
+   * @param animationUri 动画资源的 URI
+   */
+  public static loadAnimationByUri(animationUri: string): void {
+    const animationResource: AnimationResource = {
+      source: animationUri,
+    };
+    this.loadAnimation(animationResource);
+  }
+}
+
+export default AnimationsManager;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/BaseCommand.ts

@@ -0,0 +1,24 @@
+// 定义 CanExecuteHandler 类型
+type CanExecuteHandler = (parameter: any) => boolean;
+// 定义 ExecuteHandler 类型
+type ExecuteHandler = (parameter: any) => void;
+
+export class BaseCommand {
+    private canExecuteHandler: CanExecuteHandler | null;
+    private executeHandler: ExecuteHandler;
+
+    constructor(executeHandler: ExecuteHandler, canExecuteHandler: CanExecuteHandler | null = null) {
+        this.canExecuteHandler = canExecuteHandler;
+        this.executeHandler = executeHandler;
+    }
+
+    public canExecute(parameter: any): boolean {
+        return this.canExecuteHandler === null ? true : this.canExecuteHandler(parameter);
+    }
+
+    public execute(parameter: any): void {
+        if (this.executeHandler) {
+            this.executeHandler(parameter);
+        }
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/CacheManager.ts

@@ -0,0 +1,83 @@
+// 模拟 CacheItemRemovedReason 枚举
+enum CacheItemRemovedReason {
+    DependencyChanged,
+    Expired,
+    Removed,
+    Underused
+}
+
+class CacheManager {
+    private static webCache: Storage = localStorage;
+
+    static get GetWebCacheObj(): Storage {
+        return this.webCache;
+    }
+
+    static GetCache(cacheKey: string): any {
+        if (cacheKey.trim() === '') return null;
+        const item = this.webCache.getItem(cacheKey);
+        if (item) {
+            const { value, expiration } = JSON.parse(item);
+            if (expiration === null || Date.now() < expiration) {
+                return value;
+            } else {
+                this.RemoveCache(cacheKey);
+            }
+        }
+        return null;
+    }
+
+    static GetCacheWithFactory(cacheKey: string, valueFactory: (key: string) => any): any {
+        if (cacheKey.trim() === '') return null;
+        let ret = this.GetCache(cacheKey);
+        if (ret === null) {
+            ret = valueFactory(cacheKey);
+            this.SetCache(cacheKey, ret);
+        }
+        return ret;
+    }
+
+    static SetCache(cacheKey: string, objObject: any, timeOut: number = 3600): void {
+        if (cacheKey.trim() === '') return;
+        const expiration = timeOut === 0 ? null : Date.now() + timeOut * 1000;
+        const item = JSON.stringify({ value: objObject, expiration });
+        this.webCache.setItem(cacheKey, item);
+    }
+
+    static RemoveCache(cacheKey: string): void {
+        if (cacheKey.trim() === '') return;
+        this.webCache.removeItem(cacheKey);
+        this.onRemove(cacheKey, null, CacheItemRemovedReason.Removed);
+    }
+
+    static RemoveCacheByRegex(regexCacheKey: string): void {
+        if (regexCacheKey.trim() === '') return;
+        const reg = new RegExp(regexCacheKey);
+        for (let i = 0; i < this.webCache.length; i++) {
+            const cacheKey = this.webCache.key(i);
+            if (cacheKey && reg.test(cacheKey)) {
+                this.webCache.removeItem(cacheKey);
+                this.onRemove(cacheKey, null, CacheItemRemovedReason.Removed);
+            }
+        }
+    }
+
+    private static onRemove(key: string, val: any, reason: CacheItemRemovedReason): void {
+        switch (reason) {
+            case CacheItemRemovedReason.DependencyChanged:
+                break;
+            case CacheItemRemovedReason.Expired:
+                console.log(`[${key}]已过期`);
+                break;
+            case CacheItemRemovedReason.Removed:
+                console.log(`[${key}]已移除`);
+                break;
+            case CacheItemRemovedReason.Underused:
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+export default CacheManager;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/EncrypDecryptHelper.ts

@@ -0,0 +1,214 @@
+// 假设这些类型和函数在前端可以找到替代实现
+type Dictionary<T> = { [key: string]: T };
+type Tuple<T1, T2> = [T1, T2];
+type Func<T, R> = (arg: T) => R;
+
+// 假设这些配置和工具类在前端有相应的实现
+class PlatformSettings {
+    static EncryptsKey: string;
+    static Encoding: {
+        GetBytes: (str: string) => Uint8Array;
+        GetString: (bytes: Uint8Array) => string;
+    };
+}
+
+class ConfigManager {
+    static GetInstance(): ConfigManager {
+        return new ConfigManager();
+    }
+    GetConfigValue(key: string, type: any): string {
+        // 实现配置获取逻辑
+        return '';
+    }
+}
+
+// 假设 MsgEncryptionKitLib 在前端有相应的实现
+namespace MsgEncryptionKitLib {
+    export class CryptoAgent {
+        GenSymKey(): string {
+            // 实现生成对称密钥逻辑
+            return '';
+        }
+        GenServerRandomRequest(genSymKey: string, publicKey: string): string {
+            // 实现生成服务器随机请求逻辑
+            return '';
+        }
+        ExchangeKey(genSymKey: string, serverRandom: string): string {
+            // 实现密钥交换逻辑
+            return '';
+        }
+        EncryptMessage(key: string, msg: string, publicKey: string): string {
+            // 实现加密逻辑
+            return '';
+        }
+        DecryptMessage(key: string, msg: string): string {
+            // 实现解密逻辑
+            return '';
+        }
+    }
+}
+
+// 加解密模式枚举
+enum Mode {
+    Des2FixKey = 0,
+    Sm2 = 1,
+}
+
+export default class EncrypDecryptHelper {
+
+
+
+    private static _instance: EncrypDecryptHelper;
+    private KEY = PlatformSettings.EncryptsKey;
+    private defaultMode: Mode;
+    private publicKeyFileInfo = null;// new FileInfo('Devices/Cfca/Platform.PublicKey.sm2');//TODO:加密
+    private msgEncrypt: MsgEncryptionKitLib.CryptoAgent | null = null;
+    private publicKey = '';
+    private genSymKey = '';
+    private clientKey = '';
+    private serverHandle = '';
+
+    private constructor() {
+        this.initDefaultMode();
+    }
+
+    static get Instance(): EncrypDecryptHelper {
+        if (!this._instance) {
+            this._instance = new EncrypDecryptHelper();
+        }
+        return this._instance;
+    }
+
+    get DefaultMode(): Mode {
+        return this.defaultMode;
+    }
+
+    private initDefaultMode() {
+        const configValue = ConfigManager.GetInstance().GetConfigValue('EncryptMode', null);
+        if (!Object.values(Mode).includes(parseInt(configValue))) {
+            this.defaultMode = Mode.Des2FixKey;
+        } else {
+            this.defaultMode = parseInt(configValue) as Mode;
+        }
+    }
+
+    Init(mode: Mode, init: Func<Dictionary<string>, Dictionary<string>>): boolean | null {
+        if (mode !== this.defaultMode) return null;
+        switch (mode) {
+            case Mode.Des2FixKey:
+                break;
+            case Mode.Sm2:
+                const exchange: Func<string, Tuple<string, string>> = (rqt) => {
+                    const rst = init({ ServerRandomRequest: rqt });
+                    return [rst['ServerRandom'], rst['ServerHandle']];
+                };
+                if (!this.Sm2ExchangeKey(exchange)) {
+                    this.defaultMode = Mode.Des2FixKey;
+                }
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+    //TODO 加密方式
+    static Encrypt(msgByte: Uint8Array<ArrayBuffer>, arg1: boolean): Uint8Array<ArrayBuffer> {
+        throw new Error('Method not implemented.');
+    }
+    static Decrypt(message: Uint8Array<ArrayBuffer>, arg1: boolean): Uint8Array<ArrayBuffer> {
+        throw new Error('Method not implemented.');
+    }
+
+    Encrypt(msg: Uint8Array, toServer = false): Uint8Array {
+        let data: Uint8Array | null = null;
+        switch (this.defaultMode) {
+            case Mode.Des2FixKey:
+                data = this.DesEncryptFixKey(msg);
+                break;
+            case Mode.Sm2:
+                data = this.Sm2Encrypt(msg, toServer);
+                break;
+            default:
+                throw new Error(`不支持的加解方式：${this.defaultMode}`);
+        }
+        return data;
+    }
+
+    Decrypt(msg: Uint8Array, toServer = false): Uint8Array {
+        let data: Uint8Array | null = null;
+        switch (this.defaultMode) {
+            case Mode.Des2FixKey:
+                data = this.DesDecryptFixKey(msg);
+                break;
+            case Mode.Sm2:
+                data = this.Sm2Decrypt(msg, toServer);
+                break;
+            default:
+                throw new Error(`不支持的加解密方式：${this.defaultMode}`);
+        }
+        return data;
+    }
+
+    private DesEncryptFixKey(msg: Uint8Array): Uint8Array {
+        const byKey = PlatformSettings.Encoding.GetBytes(this.KEY);
+        const IV = new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
+        // 这里需要使用前端可用的 DES 加密库实现
+        const encrypted = new Uint8Array();
+        return PlatformSettings.Encoding.GetBytes(btoa(String.fromCharCode.apply(null, encrypted)));
+    }
+
+    private DesDecryptFixKey(msg: Uint8Array): Uint8Array {
+        const byKey = PlatformSettings.Encoding.GetBytes(this.KEY);
+        const IV = new Uint8Array([0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]);
+        const inputByteArray = Uint8Array.from(atob(PlatformSettings.Encoding.GetString(msg)).split('').map(c => c.charCodeAt(0)));
+        // 这里需要使用前端可用的 DES 解密库实现
+        const decrypted = new Uint8Array();
+        return decrypted;
+    }
+
+    private Sm2Init(): boolean {
+        if (!this.msgEncrypt) {
+            try {
+                // 这里需要使用前端可用的文件读取方式实现
+                this.publicKey = '';
+                this.msgEncrypt = new MsgEncryptionKitLib.CryptoAgent();
+                this.genSymKey = this.msgEncrypt.GenSymKey();
+            } catch (error) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private Sm2ExchangeKey(exChange: Func<string, Tuple<string, string>>): boolean {
+        if (this.Sm2Init()) {
+            if (this.clientKey) return true;
+            const rqt = this.msgEncrypt!.GenServerRandomRequest(this.genSymKey, this.publicKey);
+            const [serverRandom, serverHandle] = exChange(rqt);
+            this.clientKey = this.msgEncrypt!.ExchangeKey(this.genSymKey, serverRandom);
+            this.serverHandle = serverHandle;
+            return true;
+        }
+        return false;
+    }
+
+    private Sm2Encrypt(msg: Uint8Array, exChange = true): Uint8Array {
+        if (!this.Sm2Init()) return new Uint8Array();
+        const key = exChange && this.clientKey ? this.clientKey : this.genSymKey;
+        const rst = this.msgEncrypt!.EncryptMessage(key, btoa(String.fromCharCode.apply(null, msg)), this.publicKey);
+        if (exChange) {
+            const prefix = `SM2${this.serverHandle.length.toString().padStart(4, '0')}${this.serverHandle}`;
+            return PlatformSettings.Encoding.GetBytes(prefix + rst);
+        }
+        return PlatformSettings.Encoding.GetBytes(rst);
+    }
+
+    private Sm2Decrypt(msg: Uint8Array, exChange = true): Uint8Array {
+        if (!this.Sm2Init()) return new Uint8Array();
+        const key = exChange && this.clientKey ? this.clientKey : this.genSymKey;
+        const rst = this.msgEncrypt!.DecryptMessage(key, btoa(String.fromCharCode.apply(null, msg)));
+        return Uint8Array.from(atob(rst).split('').map(c => c.charCodeAt(0)));
+    }
+}
+
+export { EncrypDecryptHelper, Mode };

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/EventAggregator.ts

@@ -0,0 +1,117 @@
+// 标记接口，用于标识实现了消息处理功能的类 TODO 注调了
+//interface IHandle {}
+
+// 泛型接口，用于处理特定类型的消息
+interface IHandle<TMessage> {//extends IHandle TODO 报错
+    // 处理传入的消息
+    Handle(message: TMessage): void;
+}
+
+// 事件聚合器接口，定义了事件聚合器的基本功能
+interface IEventAggregator {
+    // 默认的线程调度器，用于消息发布时的线程管理
+    PublicationThreadMarshaller: (action: () => void) => void;
+    // 订阅消息，将实现了 IHandle<T> 接口的实例添加到事件聚合器中
+    Subscribe(instance: any): void;
+    // 取消订阅，将指定的实例从事件聚合器中移除
+    Unsubscribe(instance: any): void;
+    // 使用默认的线程调度器发布消息
+    Publish(message: any): void;
+    // 使用指定的线程调度器发布消息
+    Publish(message: any, marshal: (action: () => void) => void): void;
+}
+
+// 事件聚合器的具体实现
+class EventAggregator implements IEventAggregator {
+    // 存储所有的消息处理程序
+    private handlers: Handler[] = [];
+    // 默认的线程调度器，直接执行传入的操作
+    public static DefaultPublicationThreadMarshaller: (action: () => void) => void = (action) => action();
+    // 用于设置默认的线程调度器
+    public PublicationThreadMarshaller: (action: () => void) => void;
+
+    constructor() {
+        // 初始化 PublicationThreadMarshaller 为默认的线程调度器
+        this.PublicationThreadMarshaller = EventAggregator.DefaultPublicationThreadMarshaller;
+    }
+
+    // 订阅消息
+    public Subscribe(instance: any): void {
+        if (this.handlers.some(x => x.Matches(instance))) {
+            return;
+        }
+        // 创建一个新的 Handler 实例并添加到 handlers 列表中
+        this.handlers.push(new Handler(instance));
+    }
+
+    // 取消订阅
+    public Unsubscribe(instance: any): void {
+        const found = this.handlers.find(x => x.Matches(instance));
+        if (found) {
+            // 从 handlers 列表中移除指定的实例
+            this.handlers = this.handlers.filter(x => x !== found);
+        }
+    }
+
+    // 使用默认的线程调度器发布消息 TODO
+    public Publish(message: any): void {
+        //this.Publish(message, this.PublicationThreadMarshaller);
+    }
+    //TODO 线程消息发布订阅的模式是否ts中是否有其他的方式能实现
+    //使用指定的线程调度器发布消息
+    // public Publish(message: any, marshal: (action: () => void) => void): void {
+    //     const toNotify = [...this.handlers];
+    //     marshal(() => {
+    //         const messageType = message.constructor;
+    //         const dead = toNotify
+    //             .filter(handler => !handler.Handle(messageType, message))
+    //             .toArray();
+    //         if (dead.length > 0) {
+    //             this.handlers = this.handlers.filter(x => !dead.includes(x));
+    //         }
+    //     });
+    // }
+}
+
+// 用于存储订阅者的信息和处理方法
+class Handler {
+    // 存储订阅者的实例
+    private reference: WeakRef<any>;
+    // 存储订阅者支持处理的消息类型和对应的处理方法
+    private supportedHandlers: Map<Function, ((message: any) => void)> = new Map();
+
+    constructor(handler: any) {
+        this.reference = new WeakRef(handler);
+        const handlerInfo = null;//(IHandle as any).prototype; TODO 这个IHandle
+        const interfaces = Object.getPrototypeOf(handler).constructor
+            .getInterfaces()
+            .filter(x => x.prototype instanceof handlerInfo && x.typeParameters.length > 0);
+        // interfaces.forEach((@interface: any) => { TODO注掉了
+        //     const type = @interface.typeParameters[0];
+        //     const method = @interface.prototype.Handle;
+        //     this.supportedHandlers.set(type, method.bind(handler));
+        // });
+    }
+
+    // 检查 reference 指向的实例是否与指定的实例相同
+    public Matches(instance: any): boolean {
+        return this.reference.deref() === instance;
+    }
+
+    // 处理消息
+    public Handle(messageType: Function, message: any): boolean {
+        const target = this.reference.deref();
+        if (!target) {
+            return false;
+        }
+        for (const [key, value] of this.supportedHandlers) {
+            if (key.prototype.isPrototypeOf(message)) {
+                value(message);
+                return true;
+            }
+        }
+        return true;
+    }
+}
+
+export { IHandle, IHandle as IHandleGeneric, IEventAggregator, EventAggregator };

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/NotificationObject.ts

@@ -0,0 +1,47 @@
+import { reactive, watch } from 'vue';
+
+// 定义一个接口，用于表示属性更改事件处理函数
+type PropertyChangedEventHandler = (propertyName: string) => void;
+
+// 定义 NotificationObject 类
+export class NotificationObject {
+    private _properties: { [key: string]: any };
+    public PropertyChanged: PropertyChangedEventHandler | null = null;
+
+    constructor() {
+        // 使用 Vue 的 reactive 创建响应式对象
+        this._properties = reactive({});
+        // 监听属性变化
+        watch(
+            () => this._properties,
+            (newValue, oldValue, onCleanup) => {
+                const changedProperties = Object.keys(newValue).filter(
+                    (key) => newValue[key] !== oldValue[key]
+                );
+                changedProperties.forEach((propertyName) => {
+                    if (this.PropertyChanged) {
+                        this.PropertyChanged(propertyName);
+                    }
+                });
+            },
+            { deep: true }
+        );
+    }
+
+    // 获取属性值
+    public getProperty(propertyName: string): any {
+        return this._properties[propertyName];
+    }
+
+    // 设置属性值
+    public setProperty(propertyName: string, value: any): void {
+        this._properties[propertyName] = value;
+    }
+
+    // 触发属性更改事件
+    public RaisePropertyChanged(propertyName: string): void {
+        if (this.PropertyChanged) {
+            this.PropertyChanged(propertyName);
+        }
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/ObservableObject.ts

@@ -0,0 +1,61 @@
+import { reactive, watch } from '@vue/reactivity';
+
+// 定义 PropertyChangedEventHandler 类型
+type PropertyChangedEventHandler = (sender: any, propertyName: string) => void;
+
+class ObservableObject {
+    // 存储属性更改事件的处理函数
+    private _propertyChangedHandlers: PropertyChangedEventHandler[] = [];
+
+    // 添加事件处理函数
+    onPropertyChanged(handler: PropertyChangedEventHandler) {
+        this._propertyChangedHandlers.push(handler);
+    }
+
+    // 移除事件处理函数
+    offPropertyChanged(handler: PropertyChangedEventHandler) {
+        const index = this._propertyChangedHandlers.indexOf(handler);
+        if (index > -1) {
+            this._propertyChangedHandlers.splice(index, 1);
+        }
+    }
+
+    // 获取属性名称
+    static getPropertyName<T>(getter: () => T): string {
+        const propertyName = Object.keys(new Proxy({}, {
+            get(target, prop) {
+                return prop;
+            }
+        })).find(prop => getter() === prop);
+        return propertyName || '';
+    }
+
+    // 触发属性更改事件
+    protected raisePropertyChanged(propertyName: string) {
+        this._propertyChangedHandlers.forEach(handler => {
+            handler(this, propertyName);
+        });
+    }
+
+    // 通过表达式触发属性更改事件
+    protected raisePropertyChangedByExpression<T>(getter: () => T) {
+        const propertyName = ObservableObject.getPropertyName(getter);
+        if (propertyName) {
+            this.raisePropertyChanged(propertyName);
+        }
+    }
+
+    // 创建响应式对象
+    createReactive<T extends object>(obj: T): object {//TODO这里由T泛型改为 object
+        const reactiveObj = reactive(obj);
+        // 监听所有属性的变化
+        watch(() => Object.values(reactiveObj), () => {
+            Object.keys(reactiveObj).forEach(key => {
+                this.raisePropertyChanged(key);
+            });
+        }, { deep: true });
+        return reactiveObj;
+    }
+}
+
+export default ObservableObject;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/ThemesManager.ts

@@ -0,0 +1,29 @@
+class ThemesManager {
+    private static CurrentThemeAssemblyName: string;
+
+    public static LoadTheme(themeAssemblyName: string): void {
+        if (ThemesManager.CurrentThemeAssemblyName !== themeAssemblyName) {
+            ThemesManager.CurrentThemeAssemblyName = themeAssemblyName;
+
+            // 清除现有的主题样式
+            const existingLinks = document.querySelectorAll('link[rel="stylesheet"][data-theme]');
+            existingLinks.forEach(link => link.parentNode?.removeChild(link));
+
+            // 加载基本主题
+            const baseThemeLink = document.createElement('link');
+            baseThemeLink.rel = 'stylesheet';
+            baseThemeLink.href = '/Platform.BaseTheme/CommonResources.css';
+            baseThemeLink.dataset.theme = 'base';
+            document.head.appendChild(baseThemeLink);
+
+            // 加载指定主题
+            const projectThemeLink = document.createElement('link');
+            projectThemeLink.rel = 'stylesheet';
+            projectThemeLink.href = `/${themeAssemblyName}/CommonResources.css`;
+            projectThemeLink.dataset.theme = 'project';
+            document.head.appendChild(projectThemeLink);
+        }
+    }
+}
+
+export default ThemesManager;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/BaseClasses/TimerManager.ts

@@ -0,0 +1,80 @@
+class TimerManager {
+    private static _instance: TimerManager;
+    public static get Instance(): TimerManager {
+        if (!this._instance) {
+            this._instance = new TimerManager();
+        }
+        return this._instance;
+    }
+
+    private interval = 1000; // 1 秒
+    private counter = 0;
+    private timer: NodeJS.Timeout | null = null;
+    private timerPolicies: TimerPolicy[] = [];
+
+    private constructor() {
+        this.timer = setInterval(() => {
+            this.timerPolicies.forEach(item => {
+                if (this.counter * this.interval % item.interval === 0) {
+                    if (item.isAsynchronization) {
+                        setTimeout(item.action, 0);
+                    } else {
+                        item.action();
+                    }
+                }
+            });
+            if (this.counter === Number.MAX_SAFE_INTEGER) {
+                this.counter = 0;
+            }
+            this.counter++;
+        }, this.interval);
+    }
+
+    public addTimerPolicy(policy: TimerPolicy) {
+        if (!policy || !policy.action) return;
+        this.timerPolicies.push(policy);
+        if (!this.timer) {
+            this.timer = setInterval(() => {
+                this.timerPolicies.forEach(item => {
+                    if (this.counter * this.interval % item.interval === 0) {
+                        if (item.isAsynchronization) {
+                            setTimeout(item.action, 0);
+                        } else {
+                            item.action();
+                        }
+                    }
+                });
+                if (this.counter === Number.MAX_SAFE_INTEGER) {
+                    this.counter = 0;
+                }
+                this.counter++;
+            }, this.interval);
+        }
+    }
+
+    public removeTimerPolicy(policy: TimerPolicy) {
+        if (!policy) return;
+        const index = this.timerPolicies.indexOf(policy);
+        if (index !== -1) {
+            this.timerPolicies.splice(index, 1);
+        }
+        if (this.timer && this.timerPolicies.length === 0) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+}
+
+class TimerPolicy {
+    constructor(
+        public action: () => void,
+        public interval: number,
+        public isAsynchronization = false
+    ) {
+        if (!interval) {
+            this.interval = this.interval * 100;
+        }
+    }
+}
+
+export { TimerManager, TimerPolicy };

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Extensions/DependencyObjectExtensions.ts

@@ -0,0 +1,109 @@
+// 由于 Vue 没有直接的 DependencyObject 概念，这里使用 HTMLElement 代替
+// 同时由于没有 VisualTreeHelper 等，需要手动实现一些查找逻辑
+
+// 模拟 Predicate 类型
+type Predicate<T> = (item: T) => boolean;
+
+// 视觉树查找子元素
+function findVisualTreeChildren(target: HTMLElement, predicate?: Predicate<HTMLElement>): HTMLElement[] {
+    const result: HTMLElement[] = [];
+    if (target) {
+        const children = target.children;
+        for (let i = 0; i < children.length; i++) {
+            const element = children[i] as HTMLElement;
+            if (element) {
+                if (!predicate || predicate(element)) {
+                    result.push(element);
+                }
+                result.push(...findVisualTreeChildren(element, predicate));
+            }
+        }
+    }
+    return result;
+}
+
+// 视觉树查找第一个子元素
+function firstVisualTreeChild(target: HTMLElement, predicate?: Predicate<HTMLElement>): HTMLElement | null {
+    if (target) {
+        const children = target.children;
+        for (let i = 0; i < children.length; i++) {
+            const element = children[i] as HTMLElement;
+            if (element) {
+                if (!predicate || predicate(element)) {
+                    return element;
+                }
+                const childResult = firstVisualTreeChild(element, predicate);
+                if (childResult) {
+                    return childResult;
+                }
+            }
+        }
+    }
+    return null;
+}
+
+// 视觉树查找父元素
+function findVisualTreeAncestor(target: HTMLElement, predicate?: Predicate<HTMLElement>): HTMLElement | null {
+    if (target) {
+        const parent = target.parentElement;
+        if (!predicate) {
+            return parent;
+        } else if (parent) {
+            return predicate(parent) ? parent : findVisualTreeAncestor(parent, predicate);
+        }
+    }
+    return null;
+}
+
+// 模拟路由事件触发（在 Vue 中可以使用自定义事件）
+function raiseEvent(target: HTMLElement, event: Event) {
+    target.dispatchEvent(event);
+}
+
+// 模拟添加路由事件处理程序
+function addHandler(target: HTMLElement, eventType: string, handler: EventListenerOrEventListenerObject) {
+    target.addEventListener(eventType, handler);
+}
+
+// 模拟移除路由事件处理程序
+function removeHandler(target: HTMLElement, eventType: string, handler: EventListenerOrEventListenerObject) {
+    target.removeEventListener(eventType, handler);
+}
+
+// 在逻辑树中查找父窗口（这里简单返回 document.body）
+function getOwnerWindow(target: HTMLElement): HTMLElement | null {
+    return document.body;
+}
+
+// 查找视觉父元素
+function findVisualParent<T extends HTMLElement>(element: HTMLElement): T | null {
+    let parent: HTMLElement | null = element;
+    while (parent) {
+        if (parent instanceof HTMLElement) {
+            return parent as T;
+        }
+        parent = null;//parent.parentElement;TODO VUE上有视觉树的概念吗？
+    }
+    return null;
+}
+
+// 获取鼠标悬停的元素
+function getElementUnderMouse<T extends HTMLElement>(): T | null {
+    const element = document.elementFromPoint(window.innerWidth / 2, window.innerHeight / 2);
+    if (element instanceof HTMLElement) {
+        return findVisualParent<T>(element);
+    }
+    return null;
+}
+
+export {
+    findVisualTreeChildren,
+    firstVisualTreeChild,
+    findVisualTreeAncestor,
+    raiseEvent,
+    addHandler,
+    removeHandler,
+    getOwnerWindow,
+    findVisualParent,
+    getElementUnderMouse
+};

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Extensions/DictionaryExtension.ts

@@ -0,0 +1,29 @@
+// 定义扩展方法所在的命名空间
+//namespace Platform.Common.BasicFunctions {
+// 扩展方法，用于获取字典中的元素
+export function GetDictionaryItem<T>(dict: { [key: string]: any }, key: string): T {
+    let result: T = null as any;
+    if (dict && dict.hasOwnProperty(key)) {
+        result = dict[key] as T;
+    }
+    return result;
+}
+
+// 扩展方法，用于设置字典中的元素
+export function SetDictionaryItem(dict: { [key: string]: any }, key: string, value: any): void {
+    if (!dict) {
+        dict = {};
+    }
+    if (!dict.hasOwnProperty(key)) {
+        dict[key] = value;
+    } else {
+        dict[key] = value;
+    }
+}
+//}
+
+// // 示例使用
+// const myDict: { [key: string]: any } = {};
+// Platform.Common.BasicFunctions.setDictionaryItem(myDict, "testKey", "testValue");
+// const value = Platform.Common.BasicFunctions.getDictionaryItem<string>(myDict, "testKey");
+// console.log(value);

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Extensions/DispatcherObjectExtension.ts

@@ -0,0 +1,91 @@
+// 模拟 DispatcherObject
+class DispatcherObject {
+    // 模拟 Dispatcher
+    public dispatcher: {
+        checkAccess: () => boolean;
+        invoke: (callback: () => void) => void;
+    };
+
+    constructor() {
+        this.dispatcher = {
+            checkAccess: () => true, // 简单模拟，始终返回 true
+            invoke: (callback) => {
+                setTimeout(callback, 0); // 模拟在主线程执行
+            },
+        };
+    }
+}
+
+// 扩展方法实现
+class DispatcherObjectExtension {
+    public static UIInvoke(target: DispatcherObject, method: (...args: any[]) => any): any {
+        if (target.dispatcher.checkAccess()) {
+            return method();
+        } else {
+            return new Promise((resolve) => {
+                target.dispatcher.invoke(() => {
+                    const result = method();
+                    resolve(result);
+                });
+            });
+        }
+    }
+
+    public static UIInvokeWithType<T>(target: DispatcherObject, method: (...args: any[]) => T): T | Promise<T> {
+        if (target.dispatcher.checkAccess()) {
+            return method();
+        } else {
+            return new Promise((resolve) => {
+                target.dispatcher.invoke(() => {
+                    const result = method();
+                    resolve(result);
+                });
+            });
+        }
+    }
+
+    public static UIInvokeAction(target: DispatcherObject, action: () => void): void | Promise<void> {
+        if (target.dispatcher.checkAccess()) {
+            action();
+        } else {
+            return new Promise((resolve) => {
+                target.dispatcher.invoke(() => {
+                    action();
+                    resolve();
+                });
+            });
+        }
+    }
+}
+
+// 示例使用
+const obj = new DispatcherObject();
+const method = () => {
+    console.log('Method executed');
+    return 42;
+};
+const action = () => console.log('Action executed');
+
+// 调用 UIInvoke
+const result = DispatcherObjectExtension.UIInvoke(obj, method);
+if (result instanceof Promise) {
+    result.then((value) => console.log('Result:', value));
+} else {
+    console.log('Result:', result);
+}
+
+// 调用 UIInvokeWithType
+const typedResult = DispatcherObjectExtension.UIInvokeWithType<number>(obj, method);
+if (typedResult instanceof Promise) {
+    typedResult.then((value) => console.log('Typed Result:', value));
+} else {
+    console.log('Typed Result:', typedResult);
+}
+
+// 调用 UIInvokeAction
+const actionResult = DispatcherObjectExtension.UIInvokeAction(obj, action);
+if (actionResult instanceof Promise) {
+    actionResult.then(() => console.log('Action completed'));
+} else {
+    console.log('Action completed');
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Extensions/ICollectionExtensions.ts

@@ -0,0 +1,7 @@
+// 虽然 TypeScript 没有直接等价于 using System; 的概念，但在实际使用中，内置类型是全局可用的
+// 这里无需特殊处理
+
+// 定义接口
+export interface ICollectionExtensions {
+    // 目前接口为空，没有成员
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Extensions/IEnumerableExtensions.ts

@@ -0,0 +1,14 @@
+namespace Platform.Common.BasicFunctions {
+    export class __LINQ__ {
+        /**
+         * Applies the action to each element in the list.
+         * @param enumerable The elements to enumerate.
+         * @param action The action to apply to each item in the list.
+         */
+        static Apply<T>(enumerable: T[], action: (item: T) => void): void {
+            enumerable.forEach(item => {
+                action(item);
+            });
+        }
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Handles/BoolToVisibilityConverter.ts

@@ -0,0 +1,26 @@
+// 定义 Visibility 枚举
+enum Visibility {
+    Visible = 'visible',
+    Collapsed = 'collapsed'
+}
+
+// 定义 IValueConverter 接口
+interface IValueConverter {
+    convert(value: any, targetType: any, parameter: any, culture: any): any;
+    convertBack(value: any, targetType: any, parameter: any, culture: any): any;
+}
+
+// 实现 BoolToVisibilityConverter 类
+export class BoolToVisibilityConverter implements IValueConverter {
+    convert(value: boolean, targetType: any, parameter: any, culture: any): Visibility {
+        if (value) {
+            return Visibility.Visible;
+        } else {
+            return Visibility.Collapsed;
+        }
+    }
+
+    convertBack(value: Visibility, targetType: any, parameter: any, culture: any): boolean {
+        throw new Error('Not implemented');
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Handles/EncryptAndDecryptHandle.ts

@@ -0,0 +1,8 @@
+namespace Platform.Common.BasicFunctions {
+    export class EncryptAndDecryptHandle {
+        // 这里可以添加具体的加密和解密方法
+    }
+}
+
+// 示例使用 TODO报错暂时先注释调
+//const result = Platform.Common.BasicFunctions.EncryptAndDecryptHandle;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Handles/FileHandle.ts

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+
+export default class FileHandle {
+    /**
+     * 获取参数指定文件的MD5码
+     * @param filePath 文件路径
+     * @returns 文件的 MD5 码
+     */
+    public static async GetFileMD5(filePath: string): Promise<string> {
+        return new Promise((resolve, reject) => {
+            fs.stat(filePath, (err, stats) => {
+                if (err || !stats.isFile()) {
+                    resolve('');
+                    return;
+                }
+                const hash = crypto.createHash('md5');
+                const stream = fs.createReadStream(filePath);
+                stream.on('data', (data) => hash.update(data));
+                stream.on('end', () => {
+                    const md5 = hash.digest('hex');
+                    resolve(md5);
+                });
+                stream.on('error', (error) => {
+                    reject(error);
+                });
+            });
+        });
+    }
+
+    /**
+     * 获取参数指定文件的字节数组
+     * @param filePath 文件路径
+     * @returns 文件的字节数组
+     */
+    public static async GetBytes(filePath: string): Promise<Buffer | null> {
+        return new Promise((resolve, reject) => {
+            fs.stat(filePath, (err, stats) => {
+                if (err || !stats.isFile()) {
+                    resolve(null);
+                    return;
+                }
+                fs.readFile(filePath, (error, data) => {
+                    if (error) {
+                        reject(error);
+                    } else {
+                        resolve(data);
+                    }
+                });
+            });
+        });
+    }
+
+    /**
+     * 保存文件
+     * @param filePath 文件路径
+     * @param data 写入数据
+     * @param appendFlag 模式(true:追加   false:覆写)
+     * @returns 是否保存成功
+     */
+    public static async SaveFile(filePath: string, data: Buffer, appendFlag: boolean): Promise<boolean> {
+        return new Promise((resolve, reject) => {
+            if (!filePath) {
+                resolve(false);
+                return;
+            }
+            const dir = path.dirname(filePath);
+            fs.mkdir(dir, { recursive: true }, (err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                const flags = appendFlag ? 'a' : 'w';
+                fs.writeFile(filePath, data, { flag: flags }, (error) => {
+                    if (error) {
+                        reject(error);
+                    } else {
+                        resolve(true);
+                    }
+                });
+            });
+        });
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Handles/IndexOfIListConverter.ts

@@ -0,0 +1,36 @@
+// 定义一个 IndexOfIListConverter 类
+class IndexOfIListConverter {
+    // 实现 Convert 方法
+    public Convert(values: any[], targetType: any, parameter: any, culture: any): any {
+        // 检查 values 数组长度是否小于 2
+        if (values.length < 2) {
+            return '';
+        }
+        // 检查 values[0] 是否为数组
+        if (!Array.isArray(values[0])) {
+            return '';
+        }
+        const list = values[0];
+        // 查找 values[1] 在 list 中的索引
+        const index = list.indexOf(values[1]);
+        // 若未找到，返回空字符串
+        if (index < 0) {
+            return '';
+        }
+        // 根据 list 长度格式化索引
+        if (list.length > 10) {
+            const paddingLength = list.length.toString().length;
+            return index.toString().padStart(paddingLength, '0');
+        } else {
+            return index.toString();
+        }
+    }
+
+    // 实现 ConvertBack 方法
+    public ConvertBack(value: any, targetTypes: any[], parameter: any, culture: any): any[] {
+        throw new Error("IndexOfCollectionConverter不支持反向绑定！");
+    }
+}
+
+// 导出该类
+export default IndexOfIListConverter;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/Handles/TextToEncodingLengthConverter.ts

@@ -0,0 +1,23 @@
+// 定义 IValueConverter 接口
+interface IValueConverter {
+    convert(value: any, targetType: any, parameter: any, culture: any): any;
+    convertBack(value: any, targetType: any, parameter: any, culture: any): any;
+}
+
+// 定义 TextToEncodingLengthConverter 类
+export class TextToEncodingLengthConverter implements IValueConverter {
+    // 实现 convert 方法
+    convert(value: any, targetType: any, parameter: any, culture: any): any {
+        const text = typeof value === 'string' ? value : null;
+        if (text === null) return 0;
+
+        // 使用 TextEncoder 计算字符串的字节长度
+        const encoder = new TextEncoder();
+        return encoder.encode(text).length;
+    }
+
+    // 实现 convertBack 方法
+    convertBack(value: any, targetType: any, parameter: any, culture: any): any {
+        throw new Error('Not implemented');
+    }
+}

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/PageFunctions/TradeModel.ts

@@ -0,0 +1,109 @@
+// 假设 NotificationObject 类的定义如下
+class NotificationObject {
+    protected raisePropertyChanged(propertyName: string) {
+        // 这里可以实现属性变更通知的逻辑
+        console.log(`Property ${propertyName} has changed.`);
+    }
+}
+
+// 假设 TradeModelHelper 类的定义如下
+class TradeModelHelper {
+    static GetMetadata(model: TradeModel): { [key: string]: string } {
+        // 实现获取元数据的逻辑
+        return {};
+    }
+
+    static SetMetadata(model: TradeModel, dic: { [key: string]: string }) {
+        // 实现设置元数据的逻辑
+    }
+
+    static GetRight(model: TradeModel): string[] {
+        // 实现获取权限的逻辑
+        return [];
+    }
+
+    static SetRight(model: TradeModel, right: string[]) {
+        // 实现设置权限的逻辑
+    }
+}
+
+class TradeModel extends NotificationObject {
+    private _guid: string;
+    private _name: string;
+    private _code: string;
+    private _action: string;
+    private _type: string;
+    private _parentID: string;
+
+    get GUID(): string {
+        return this._guid;
+    }
+
+    set GUID(value: string) {
+        this._guid = value;
+    }
+
+    get Name(): string {
+        return this._name;
+    }
+
+    set Name(value: string) {
+        this._name = value;
+        this.raisePropertyChanged("Name");
+    }
+
+    get Code(): string {
+        return this._code;
+    }
+
+    set Code(value: string) {
+        this._code = value;
+        this.raisePropertyChanged("Code");
+    }
+
+    get Action(): string {
+        return this._action;
+    }
+
+    set Action(value: string) {
+        this._action = value;
+    }
+
+    get Metadata(): { [key: string]: string } {
+        return TradeModelHelper.GetMetadata(this);
+    }
+
+    SetMetadata(dic: { [key: string]: string }) {
+        TradeModelHelper.SetMetadata(this, dic);
+    }
+
+    get Right(): string[] {
+        return TradeModelHelper.GetRight(this);
+    }
+
+    SetRight(right: string[]) {
+        TradeModelHelper.SetRight(this, right);
+    }
+
+    get Type(): string {
+        return this._type;
+    }
+
+    set Type(value: string) {
+        this._type = value;
+    }
+
+    get ParentID(): string {
+        return this._parentID;
+    }
+
+    set ParentID(value: string) {
+        this._parentID = value;
+    }
+
+    constructor() {
+        super();
+    }
+}
+
+export default TradeModel;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/PageFunctions/TradeModelHelper.ts

@@ -0,0 +1,36 @@
+// 假设 TradeModel 类型已经定义
+interface TradeModel {
+    // 这里可以根据实际情况定义 TradeModel 的属性
+}
+
+class TradeModelHelper {
+    // 模拟 Metadata 附加属性
+    private static metadataMap = new WeakMap<object, { [key: string]: string }>();
+
+    static getMetadata(obj: object): { [key: string]: string } | null {
+        return this.metadataMap.get(obj) || null;
+    }
+
+    static setMetadata(obj: object, value: { [key: string]: string }): void {
+        this.metadataMap.set(obj, value);
+    }
+
+    // 模拟 Right 附加属性
+    private static rightMap = new WeakMap<object, string[]>();
+
+    static getRight(obj: object): string[] | null {
+        return this.rightMap.get(obj) || null;
+    }
+
+    static setRight(obj: object, value: string[]): void {
+        this.rightMap.set(obj, value);
+    }
+
+    // 获取交易模型列表
+    static getTradeModelList(parentModel: TradeModel): TradeModel[] {
+        let lstResult: TradeModel[] = [];
+        return lstResult;
+    }
+}
+
+export default TradeModelHelper;

ant-design-pro-vue3/src/views/front/platfrom/common/BasicFunctions/PageFunctions/TradeViewModel.ts

@@ -0,0 +1,128 @@
+// 假设 NotificationObject 类的定义如下
+class NotificationObject {
+    protected raisePropertyChanged(propertyName: string) {
+        // 实现属性变更通知逻辑
+    }
+}
+
+// 假设 TradeModel 类的定义如下
+class TradeModel {
+    GUID: string;
+    ParentID: string;
+    Name: string;
+    Code: string;
+    Type: string;
+}
+
+// 假设 ConfigManager 类的定义如下
+class ConfigManager {
+    private static instance: ConfigManager;
+    private constructor() {}
+
+    public static GetInstance() {
+        if (!this.instance) {
+            this.instance = new ConfigManager();
+        }
+        return this.instance;
+    }
+
+    public GetConfigValue(key: string, type: string) {
+        // 实现获取配置值的逻辑
+        return "";
+    }
+}
+
+class TradeViewModel extends NotificationObject {
+    private _isleaf: boolean = false;
+    private _node: TradeModel | null = null;
+    public Parent: TradeViewModel | null = null;
+    public IsSelected: boolean = false;
+    public IsExpanded: boolean = false;
+    private _children: TradeViewModel[] = [];
+
+    get Node() {
+        return this._node;
+    }
+
+    set Node(value: TradeModel | null) {
+        this._node = value;
+        this.raisePropertyChanged("Node");
+    }
+
+    get IsLeaf() {
+        return this._isleaf;
+    }
+
+    set IsLeaf(value: boolean) {
+        this._isleaf = value;
+        this.raisePropertyChanged("IsLeaf");
+    }
+
+    get Children() {
+        return this._children;
+    }
+
+    set Children(value: TradeViewModel[]) {
+        this._children = value;
+        this.raisePropertyChanged("Children");
+    }
+
+    public static GetRootNode(ModelList: TradeModel[]): TradeViewModel[] {
+        const VMList: TradeViewModel[] = [];
+        const list = ModelList.filter(x => !x.ParentID);
+        for (const item of list) {
+            const vm = TradeViewModel.CreateVm(ModelList, item);
+            if (vm) {
+                VMList.push(vm);
+            }
+        }
+
+        // 常用交易菜单添加
+        // const tradeModel = new TradeModel();
+        // tradeModel.Name = "常用交易";
+        // const tradeViewModel = new TradeViewModel();
+        // tradeViewModel.Node = tradeModel;
+        // const commonTradeCodes = ConfigManager.GetInstance().GetConfigValue("CommonTrade", "User").split('|').filter(s => s);
+        // for (const code of commonTradeCodes) {
+        //     const matchingModels = ModelList.filter(x => x.Code === code);
+        //     for (const b of matchingModels) {
+        //         const child = new TradeViewModel();
+        //         child.Node = b;
+        //         child.IsLeaf = true;
+        //         child.Children = [];
+        //         tradeViewModel.Children.push(child);
+        //     }
+        // }
+        // VMList.push(tradeViewModel);
+
+        return VMList;
+    }
+
+    private static CreateVm(models: TradeModel[], current: TradeModel): TradeViewModel | null {
+        const result = new TradeViewModel();
+        result.Node = current;
+        const list = models.filter(x => x.ParentID === result.Node?.GUID);
+        if (list.length === 0) {
+            if (current.Type === "category") {
+                return null;
+            }
+            result.IsLeaf = true;
+            result.Children = [];
+        } else {
+            result.IsLeaf = false;
+            for (const item of list) {
+                const child = TradeViewModel.CreateVm(models, item);
+                if (child) {
+                    child.Parent = result;
+                    result.Children.push(child);
+                }
+            }
+            if (result.Children.length === 0) {
+                return null;
+            }
+        }
+        return result;
+    }
+}
+
+export { TradeViewModel, TradeModel };

ant-design-pro-vue3/src/views/front/platfrom/common/LogSystem/LogWriter.ts

@@ -0,0 +1,124 @@
+//import { ILog, Level } from 'log4net'; // 假设 log4net 有对应的 TypeScript 定义//TODO日志信息可以先不登记
+
+// 假设的 LoginUserInfo 类
+class LoginUserInfo {
+    static TellerNo: string;
+}
+
+// 假设的 PlatformSettings 类
+class PlatformSettings {
+    static IsDebugMode: boolean;
+    static Encoding: {
+        GetBytes: (str: string) => Uint8Array;
+        GetString: (bytes: Uint8Array) => string;
+    };
+}
+
+// 假设的 EncrypDecryptHelper 类
+class EncrypDecryptHelper {
+    static Instance: {
+        DesEncryptFixKey: (bytes: Uint8Array) => Uint8Array;
+    };
+}
+
+// 日志数据类
+class LogData {
+    constructor(
+        //public LogObject: ILog,//TODO日志信息可以先不登记
+        //public LogLevel: Level,//TODO日志信息可以先不登记
+        public Content: string,
+        public TradeNo: string = null,
+        public LogException: Error = null
+    ) {
+        this.TellerNo = LoginUserInfo.TellerNo;
+        this.LogDate = new Date().toISOString().replace('T', ' ').substring(0, 19);
+    }
+
+    //public LogObject: ILog;//TODO日志信息可以先不登记
+    //ublic LogLevel: Level;
+    //public TradeNo: string;
+    public LogDate: string;
+    public TellerNo: string;
+    //public Content: string;
+    //public LogException: Error;
+    public AttachData: any;
+}
+
+// 日志记录器类
+class LogWriter {
+    private static _instance: LogWriter;
+    private static _LogDataList: LogData[] = [];
+
+    public static get Instance(): LogWriter {
+        if (!this._instance) {
+            this._instance = new LogWriter();
+        }
+        return this._instance;
+    }
+
+    private constructor() {
+        // 定时任务部分暂时无法实现，因为 JavaScript 没有直接对应的 TimeSpan 和 TimerManager
+    }
+
+    public AddLogData(data: LogData) {
+        LogWriter._LogDataList.push(data);
+    }
+
+    public SaveLog() {
+        if (!LogWriter._LogDataList || LogWriter._LogDataList.length === 0) return;
+
+        const list = [...LogWriter._LogDataList];
+        LogWriter._LogDataList = [];
+
+        list.forEach(item => {
+            const target = item;
+            let data = '';
+            if (target.TradeNo) {
+                data += `交易号:${target.TradeNo}\n`;
+            }
+            data += `操作柜员:${target.TellerNo}\n`;
+            data += `发生时间:${target.LogDate}\n`;
+            data += `日志信息:${target.Content}\n`;
+            if (target.LogException) {
+                data += `异常信息:${target.LogException}\n`;
+            }
+
+            let msg = data;
+            if (!PlatformSettings.IsDebugMode) {
+                const bytes = PlatformSettings.Encoding.GetBytes(msg);
+                const encryptedBytes = EncrypDecryptHelper.Instance.DesEncryptFixKey(bytes);
+                msg = PlatformSettings.Encoding.GetString(encryptedBytes);
+            }
+
+            let stringBuilder = 'Start\n';
+            stringBuilder += msg;
+            stringBuilder += 'End\n';
+
+            // this.SendToLog4net(target.LogObject, target.LogLevel, stringBuilder, null);//TODO日志信息可以先不登记
+        });
+    }
+
+    private SendToLog4net(log: "", level: "", msg: any, exception: Error) {//TODO日志信息可以先不登记(log: ILog, level: Level, msg: any, exception: Error)
+        // switch (level.Name) {
+        //     case 'DEBUG':
+        //         log.Debug(msg, exception);
+        //         break;
+        //     case 'ERROR':
+        //         log.Error(msg, exception);
+        //         break;
+        //     case 'FATAL':
+        //         log.Fatal(msg, exception);
+        //         break;
+        //     case 'INFO':
+        //         log.Info(msg, exception);
+        //         break;
+        //     case 'WARN':
+        //         log.Warn(msg, exception);
+        //         break;
+        //     default:
+        //         break;
+        // }
+    }
+}
+
+export { LogWriter, LogData };

ant-design-pro-vue3/src/views/front/platfrom/common/LogSystem/PlatformLogger.ts

@@ -0,0 +1,156 @@
+import winston from './winston'; //TODO这里日志记录使用了log4net.dll需要解决对应的方案 可以使用vuejs-logger来代替
+import LoginUserInfo from '../RunningParameters/LoginUserInfo'; // 假设 LoginUserInfo 定义在该文件中TODO：缺用户模块
+
+// 假设 LogWriter 类的实现
+class LogWriter {
+    private static instance: LogWriter;
+    private logData: any[] = [];
+
+    private constructor() { }
+
+    public static get Instance() {
+        return this.instance || (this.instance = new this());
+    }
+
+    public AddLogData(data: any) {
+        this.logData.push(data);
+    }
+
+    public SaveLog() {
+        // 实现保存日志的逻辑
+    }
+}
+
+// 定义日志记录器
+const lg1 = winston.createLogger("lg1");
+const lg2 = winston.createLogger("lg2");
+const lg3 = winston.createLogger("lg3");
+const lg4 = winston.createLogger("lg4");
+const lg5 = winston.createLogger("lg5");
+
+// 日志文件开关状态
+const dics: { [key: string]: string } = {
+    'System.log': 'on',
+    'Debug.log': 'on',
+    'Message.log': 'on',
+    'Error.log': 'on',
+};
+
+// 创建连接
+function CreateConnection(tellerNo: string, tradeDate: string) {
+    // 实现创建连接的逻辑
+}
+
+// 关闭连接
+function CloseConnection() {
+    // 实现关闭连接的逻辑
+}
+
+// 系统正常运行的输出日志
+export function SystemInfo(logDetail: string) {
+    CreateConnection(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate);
+    LogWriter.Instance.AddLogData({ logger: lg1, level: 'debug', message: logDetail });
+    LogWriter.Instance.SaveLog();
+    CloseConnection();
+}
+
+// 交易正常运行的输出日志
+export function TradeInfo(logDetail: string, tradeNum = '****') {
+    CreateConnection(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate);
+    LogWriter.Instance.AddLogData({ logger: lg2, level: 'debug', message: logDetail, tradeNum });
+    LogWriter.Instance.SaveLog();
+    CloseConnection();
+}
+
+// 交易异常的输出日志
+export function TradeErrorInfo(errMsg: string, ex: Error, tradeNum = '****') {
+    CreateConnection(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate);
+    LogWriter.Instance.AddLogData({ logger: lg3, level: 'error', message: errMsg, tradeNum, ex });
+    LogWriter.Instance.SaveLog();
+    CloseConnection();
+}
+
+// 普通异常(不属于交易异常)的输出日志
+export function SystemErrorInfo(errMsg: string, ex: Error) {
+    CreateConnection(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate);
+    LogWriter.Instance.AddLogData({ logger: lg5, level: 'error', message: errMsg, ex });
+    LogWriter.Instance.SaveLog();
+    CloseConnection();
+}
+
+// 通讯内容的输出日志
+export function CommunicationInfo(msg: string, tradeNum = '****') {
+    CreateConnection(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate);
+    LogWriter.Instance.AddLogData({ logger: lg4, level: 'debug', message: msg, tradeNum });
+    LogWriter.Instance.SaveLog();
+    CloseConnection();
+}
+
+// 获取待上传的目录路径
+export function GetUploadDataPath(isChecked: boolean): string {
+    CloseConnection();
+    if (isChecked) {
+        if (CanbeSent(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate)) {
+            return GetBackUp();
+        }
+    } else {
+        return GetBackUp();
+    }
+    CreateConnection(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate);
+    return '';
+}
+
+// 更改输出配置
+export function ChangeOutput() {
+    CloseConnection();
+    CreateConnection(LoginUserInfo.TellerNo, LoginUserInfo.TradeDate);
+}
+
+// 判断日志文件是否满足上传条件
+function CanbeSent(path: string, tradeDate: string): boolean {
+    // 实现判断逻辑
+    return false;
+}
+
+// 检查日志文件是否能写入
+function CheckSwitchOfFile(logger: "", dic: { [key: string]: string }) {//TODO(logger: winston.Logger, dic: { [key: string]: string })
+    // 实现检查逻辑
+}
+
+// 获取日志文件的最近上传时间
+function GetLastSentTime(fInfo: any): Date {
+    // 实现获取时间逻辑
+    return new Date();
+}
+
+// 获取日志文件的大小
+function GetSizeOfFile(fInfo: any): number {
+    // 实现获取大小逻辑
+    return 0;
+}
+const enum Enum {
+    A = 1,
+    B = A * 2,
+}
+// 为指定的日志记录器添加输出文件
+function SetAppender(logger: "", appender: any) {//TODO(logger: winston.Logger, appender: any)
+    // 实现添加输出文件逻辑
+}
+
+// 创建输出文件
+function CreateAppender(tellerNo: string, fileName: string): any {
+    // 实现创建输出文件逻辑
+    return {};
+}
+
+// 截屏函数
+function CutScreen(): string {
+    // 实现截屏逻辑
+    return '';
+}
+
+// 对待上传的目录进行备份，并返回目录路径
+function GetBackUp(): string {
+    // 实现备份逻辑
+    return '';
+}

ant-design-pro-vue3/src/views/front/platfrom/common/LogSystem/winston.ts

@@ -0,0 +1,10 @@
+///此文件是为了platformLogger报错写的问题件为了解决日志登记的问题
+export default class winston {
+
+    static createLogger<T>(key: string): string {
+        return "";
+    }
+    //日志类型枚举
+
+
+}

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

@@ -0,0 +1,61 @@
+// 定义 CommonParames 命名空间，用于存储平台运行参数
+namespace Platform.Common.RunningParameters {
+    // 定义 CommonParames 类，用于存储各种参数
+    export class CommonParames {
+        // 字符编码
+        public static Coding: string = "gb2312";
+        // 交易日志配置节点名称
+        public static readonly TradeLog: string = "TradeLogger";
+        // 错误日志配置节点名称
+        public static readonly ErrLog: string = "ErrLogger";
+        // 系统名称
+        public static SysName: string = "东华商业银行核心业务系统";
+        // 更新程序名
+        public static readonly UpdateAppName: string = "TellerSys.Update.exe";
+        // 更新进程名
+        public static readonly UpdateProcName: string = "TellerSys.Update";
+        // 客户端程序名
+        public static readonly ClientAppName: string = "TellerSys.Client.exe";
+        // 客户端进程名
+        public static readonly ClientProcName: string = "TellerSys.Client";
+        // 主程序目录
+        public static MainDir: string = "TradeDll/";
+        // 服务端---交易Dll文件存放目录
+        public static TradeInfoPath: string = "pages";
+        // 服务端---客户端更新文件所在路径
+        public static UpdatedClientPath: string = "updatedfile";
+        // 服务端---配置文件所在目录
+        public static ConfigFilePath: string = "serverconfig";
+        // 帮助文件目录
+        public static TellerSysHelp: string = "TellerSysHelp";
+        // 服务端---临时文件所在目录
+        public static TempFilePath: string = "tmp";
+        // 与核心通讯方法名
+        public static CallServerName: string = "callserver";
+        // 与支付平台通讯方法名
+        public static CallAgnName: string = "callserver";
+        // 与财税库银通讯方法名
+        public static CallTipsName: string = "callserver";
+        // 菜单配置文件名称
+        public static MenuFileName: string = "Menu.xml";
+        // 任务菜单配置文件名称
+        public static TaskMenuFileName: string = "TaskMenu.xml";
+        // 服务器端存放交易文件附件的默认路径
+        public static TradeFilePath: string = "tmp";
+        // 错误码/错误信息映射关系Map
+        public static MsgErrorMap: { [key: string]: string } = {};
+        // 登录界面标题
+        public static LoginTitle: string = "商业银行核心业务系统登录界面";
+        // 系统采用的默认字体，用于交易和打印项的设计时与运行时呈现
+        public static DefaultFontFamily: string = "Microsoft YaHei";
+        // 系统采用的默认字体大小，用于交易和打印项的设计时与运行时呈现
+        public static DefaultFontSize: number = 14;
+        // 系统设计和打印表单采用的字体
+        public static DefaultPrintFontFamily: string = "宋体";
+        // 系统设计和打印表单采用的字体大小
+        public static DefaultPrintFontSize: number = 12;
+    }
+}
+
+// 导出 CommonParames 类，方便在其他地方使用
+export default Platform.Common.RunningParameters.CommonParames;

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

@@ -0,0 +1,184 @@
+// 假设 EncrypDecryptHelper 类的实现
+class EncrypDecryptHelper {
+    static Instance = new EncrypDecryptHelper();
+
+    DesDecryptFixKey(data: Uint8Array): Uint8Array {
+        // 实现解密逻辑
+        return data;
+    }
+
+    DesEncryptFixKey(data: Uint8Array): Uint8Array {
+        // 实现加密逻辑
+        return data;
+    }
+}
+
+// 配置文件类型枚举
+enum ConfigType {
+    System,
+    Client,
+    User
+}
+
+class ConfigManager {
+    private static instance: ConfigManager;
+    private readonly _dirName = "Config";
+    private readonly _clientFileInfo = `${this._dirName}/Platform.Client.Config`;
+    private _clientDictionary: { [key: string]: string } = {};
+    private readonly _systemFileInfo = `${this._dirName}/Platform.System.Config`;
+    private _systemDictionary: { [key: string]: string } = {};
+    private readonly _userFileInfo = `${this._dirName}/Platform.User.Config`;
+    private _userDictionary: { [key: string]: string } = {};
+
+    private constructor() { }
+
+    public static GetInstance(): ConfigManager {
+        if (!this.instance) {
+            this.instance = new ConfigManager();
+        }
+        return this.instance;
+    }
+
+    public async LoadConfig(configType: ConfigType, isEncryptedFile = false): Promise<boolean> {
+        switch (configType) {
+            case ConfigType.System:
+                return this.Load(this._systemFileInfo, this._systemDictionary, isEncryptedFile);
+            case ConfigType.Client:
+                return this.Load(this._clientFileInfo, this._clientDictionary);
+            case ConfigType.User:
+                return this.Load(this._userFileInfo, this._userDictionary, isEncryptedFile);
+            default:
+                return false;
+        }
+    }
+
+    private async Load(from: string, to: { [key: string]: string }, isEncryptedFile = false): Promise<boolean> {
+        try {
+            const response = await fetch(from);
+            if (response.ok) {
+                const data = new Uint8Array(await response.arrayBuffer());
+                let decryptedData = isEncryptedFile ? EncrypDecryptHelper.Instance.DesDecryptFixKey(data) : data;
+                const xmlString = new TextDecoder().decode(decryptedData);
+                const parser = new DOMParser();
+                const doc = parser.parseFromString(xmlString, "application/xml");
+                const elementCollection = doc.documentElement.children;
+                for (let i = 0; i < elementCollection.length; i++) {
+                    const element = elementCollection[i];
+                    const elementKey = element.getAttribute("key");
+                    const elementValue = element.getAttribute("value");
+                    if (!elementKey) break;
+                    if (to.hasOwnProperty(elementKey)) {
+                        to[elementKey] = elementValue || "";
+                    } else {
+                        to[elementKey] = elementValue || "";
+                    }
+                }
+                return true;
+            } else {
+                return false;
+            }
+        } catch (error) {
+            return false;
+        }
+    }
+
+    public async SaveConfig(configType: ConfigType, isEncryptedFile = false): Promise<string | null> {
+        switch (configType) {
+            case ConfigType.System:
+                return this.Save(this._systemDictionary, this._systemFileInfo, isEncryptedFile);
+            case ConfigType.Client:
+                return this.Save(this._clientDictionary, this._clientFileInfo);
+            case ConfigType.User:
+                return this.Save(this._userDictionary, this._userFileInfo, isEncryptedFile);
+            default:
+                return null;
+        }
+    }
+
+    private async Save(from: { [key: string]: string }, to: string, isEncryptedFile = false): Promise<string | null> {
+        const xmlDoc = document.implementation.createDocument(null, "elements");
+        xmlDoc.appendChild(xmlDoc.createProcessingInstruction("xml", 'version="1.0" encoding="UTF-8"'));
+        for (const [key, value] of Object.entries(from)) {
+            const element = xmlDoc.createElement("element");
+            element.setAttribute("key", key);
+            element.setAttribute("value", value);
+            xmlDoc.documentElement.appendChild(element);
+        }
+        const serializer = new XMLSerializer();
+        const xmlString = serializer.serializeToString(xmlDoc);
+        let data = new TextEncoder().encode(xmlString);
+        if (isEncryptedFile) {
+            data = EncrypDecryptHelper.Instance.DesEncryptFixKey(data);
+        }
+        try {
+            await fetch(to, {
+                method: "PUT",
+                body: data
+            });
+            return to;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    public GetConfigValue(key: string, configType: ConfigType): string {
+        let ret = "";
+        if (key) {
+            switch (configType) {
+                case ConfigType.System:
+                    if (this._systemDictionary.hasOwnProperty(key)) {
+                        ret = this._systemDictionary[key];
+                    }
+                    break;
+                case ConfigType.Client:
+                    if (this._clientDictionary.hasOwnProperty(key)) {
+                        ret = this._clientDictionary[key];
+                    }
+                    break;
+                case ConfigType.User:
+                    if (this._userDictionary.hasOwnProperty(key)) {
+                        ret = this._userDictionary[key];
+                    }
+                    break;
+                default: break;
+            }
+        }
+        return ret;
+    }
+
+    public SetConfigValue(key: string, value: string, configType: ConfigType): boolean {
+        let ret = false;
+        if (key) {
+            switch (configType) {
+                case ConfigType.System:
+                    if (this._systemDictionary.hasOwnProperty(key)) {
+                        this._systemDictionary[key] = value;
+                    } else {
+                        this._systemDictionary[key] = value;
+                    }
+                    ret = true;
+                    break;
+                case ConfigType.Client:
+                    if (this._clientDictionary.hasOwnProperty(key)) {
+                        this._clientDictionary[key] = value;
+                    } else {
+                        this._clientDictionary[key] = value;
+                    }
+                    ret = true;
+                    break;
+                case ConfigType.User:
+                    if (this._userDictionary.hasOwnProperty(key)) {
+                        this._userDictionary[key] = value;
+                    } else {
+                        this._userDictionary[key] = value;
+                    }
+                    ret = true;
+                    break;
+                default: break;
+            }
+        }
+        return ret;
+    }
+}
+
+export { ConfigManager, ConfigType };

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

@@ -0,0 +1,60 @@
+import { GetDictionaryItem, SetDictionaryItem } from "../BasicFunctions/Extensions/DictionaryExtension";
+
+// 假设 TradeModel 类型已经定义
+interface TradeModel {
+    // 这里可以根据实际情况定义 TradeModel 的属性
+}
+
+export default class LoginUserInfo {
+    // 缓存数据，柜员登陆时加载
+    private static _dict: { [key: string]: any } = {};
+
+    // 操作员基础信息
+    static get KinbrNo(): string {
+        return this.GetUserInfo('KinbrNo');
+    }
+
+    static get KinbrName(): string {
+        return this.GetUserInfo('KinbrName');
+    }
+
+    static get TellerNo(): string {
+        return this.GetUserInfo('TellerNo');
+    }
+
+    static get TellerName(): string {
+        return this.GetUserInfo('TellerName');
+    }
+
+    static get TtyName(): string {
+        return this.GetUserInfo('TtyName');
+    }
+
+    static get TradeDate(): string {
+        return this.GetUserInfo('TradeDate');
+    }
+
+    static get TradeRight(): TradeModel[] {
+        return this.GetUserInfo<TradeModel[]>('TradeRight');
+    }
+
+    // // 获取参数指定的缓存配置项 //TODO此处有两种方法 不能重载
+    // static GetUserInfo(key: string): string {
+    //     let ret = '';
+    //     if (key && this._dict.hasOwnProperty(key)) {
+    //         ret = this._dict[key] || '';
+    //     }
+    //     return ret;
+    // }
+
+    // 获取参数指定的缓冲配置项，并转换成相应类型
+    static GetUserInfo<T>(key: string): T {
+        return GetDictionaryItem<T>(this._dict, key);
+    }
+
+    // 设置参数指定的缓冲配置项
+    static SetUserInfo(key: string, value: any): boolean {
+        SetDictionaryItem(this._dict, key, value);
+        return true;
+    }
+}

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

@@ -0,0 +1,143 @@
+// 假设 ConfigManager 和 PlatformLogger 已经在其他地方定义
+class ConfigManager {
+    private static instance: ConfigManager;
+    private constructor() { }
+
+    public static GetInstance(): ConfigManager {
+        if (!this.instance) {
+            this.instance = new ConfigManager();
+        }
+        return this.instance;
+    }
+
+    public GetConfigValue(key: string, configType: ConfigType): string {
+        // 这里需要实现从配置文件读取值的逻辑
+        return '';
+    }
+}
+
+enum ConfigType {
+    Client,
+    System
+}
+
+export default class PlatformLogger {
+    public static SystemErrorInfo(message: string, error: Error): void {
+        console.error(message, error);
+    }
+}
+
+export class PlatformSettings {
+    private static _encoding: BufferEncoding;
+
+    /**
+     * 字符编码，默认值是系统默认
+     */
+    public static get Encoding(): BufferEncoding {
+        const encName = ConfigManager.GetInstance().GetConfigValue('Encoding', ConfigType.Client);
+        if (!this._encoding) {
+            this._encoding = 'utf8'; // 假设系统默认编码为 utf8
+        }
+        if (encName !== this._encoding) {
+            try {
+                // 若编码发生变化，则更新
+                this._encoding = encName as BufferEncoding;
+            } catch (e) {
+                PlatformLogger.SystemErrorInfo(`PlatformSettings.Encoding系统参数转换异常！${encName}`, e as Error);
+            }
+        }
+        return this._encoding;
+    }
+
+    /**
+     * 是否启用调试模式,默认为不启用
+     */
+    public static get IsDebugMode(): boolean {
+        let debugModeBoolean = false;
+        const debugMode = ConfigManager.GetInstance().GetConfigValue('IsDebugMode', ConfigType.System);
+        if (debugMode) {
+            debugModeBoolean = debugMode.toLowerCase() === 'true';
+        }
+        return debugModeBoolean;
+    }
+
+    /**
+     * 平台项目名称，默认为空
+     */
+    public static get PlatformTitle(): string {
+        return ConfigManager.GetInstance().GetConfigValue('PlatformTitle', ConfigType.System);
+    }
+
+    /**
+     * 打印偏移量,默认为（0,0）
+     */
+    public static get PrinterOffset(): { x: number; y: number } {
+        let offsetPoint = { x: 0, y: 0 };
+        const offset = ConfigManager.GetInstance().GetConfigValue('PrinterOffset', ConfigType.Client);
+        if (offset) {
+            const index = offset.indexOf(',');
+            if (index > 0) {
+                const offsetX = parseFloat(offset.substring(0, index));
+                const offsetY = parseFloat(offset.slice(index + 1));
+                if (!isNaN(offsetX) && !isNaN(offsetY)) {
+                    offsetPoint = { x: offsetX, y: offsetY };
+                }
+            }
+        }
+        return offsetPoint;
+    }
+
+    /**
+     * 服务器端通讯地址
+     */
+    public static get ServiceAddress(): string {
+        return ConfigManager.GetInstance().GetConfigValue('SocketServiceAddress', ConfigType.Client);
+    }
+
+    /**
+     * 通讯超时时间,默认是1分钟,单位是毫秒
+     */
+    public static get Timeout(): number {
+        let timeout = 6000;
+        const time = ConfigManager.GetInstance().GetConfigValue('SocketTimeOut', ConfigType.Client);
+        const parsedTime = parseInt(time, 10);
+        if (!isNaN(parsedTime)) {
+            timeout = parsedTime;
+        }
+        return timeout;
+    }
+
+    /**
+     * 交易文件dll路径，默认为Pages
+     */
+    public static get PagesDirectory(): string {
+        let procName = ConfigManager.GetInstance().GetConfigValue('PagesDirectory', ConfigType.System);
+        if (!procName) {
+            procName = 'Pages';
+        }
+        return procName;
+    }
+
+    /**
+     * 是否对报文加密标志
+     */
+    public static get IsEncrypt(): boolean {
+        let EncryptBoolean = false;
+        const Encrypt = ConfigManager.GetInstance().GetConfigValue('IsEncrypt', ConfigType.Client);
+        if (Encrypt) {
+            EncryptBoolean = Encrypt.toLowerCase() === 'true';
+        }
+        return EncryptBoolean;
+    }
+
+    /**
+     * 服务端通讯报文加密KEY
+     */
+    public static get EncryptsKey(): string {
+        let encryptskey = ConfigManager.GetInstance().GetConfigValue('EncryptsKey', ConfigType.Client);
+        if (!encryptskey) {
+            encryptskey = 'DHCCSoft';
+        }
+        return encryptskey;
+    }
+}

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

@@ -0,0 +1,72 @@
+// 假设 Transit 类型定义如下
+type Transit = string; 
+
+export class TradeParames {
+    // 8583报文类型标识串
+    public static MsgType: string = "01001";
+    // 加减密字符串
+    public static KeyStr: string = "dhccnew";
+    // 交易数据日志配置节点名称
+    public static TradeDataLog: string = "TradeData";
+    // 1参数：渠道callserver,callagn,calltips
+    // 2参数：对应渠道的详细报文类型信息
+    public static MsgFormat: { [key in Transit]: { [key: string]: object } } | null = null;
+
+    // 交易参数字典
+    private static _tradeParames: Map<string, string> = new Map<string, string>();
+
+    // 机构号
+    public static get KinbrNo(): string {
+        return this.getValue("KinbrNo");
+    }
+    // 机构名称
+    public static get KinbrName(): string {
+        return this.getValue("KinbrName");
+    }
+    // 柜员号
+    public static get TellerNo(): string {
+        return this.getValue("TellerNo");
+    }
+    // 柜员姓名
+    public static get TellerName(): string {
+        return this.getValue("TellerName");
+    }
+    // 终端号
+    public static get TtyName(): string {
+        return this.getValue("TtyName");
+    }
+    // 交易日期
+    public static get TradeDate(): string {
+        return this.getValue("TradeDate");
+    }
+    // 权限
+    public static get Rights(): string {
+        return this.getValue("Rights");
+    }
+    // 开户局号
+    public static get Opnbr(): string {
+        return this.getValue("Opnbr");
+    }
+    // 密码
+    public static get Passwd(): string {
+        return this.getValue("Passwd");
+    }
+    // 柜员级别
+    public static get Tlrlvl(): string {
+        return this.getValue("Tlrlvl");
+    }
+
+    // 获取key对应的value
+    private static getValue(key: string): string {
+        if (!this._tradeParames.has(key)) {
+            this._tradeParames.set(key, "");
+        }
+        return this._tradeParames.get(key)!;
+    }
+
+    // 设置交易参数
+    public static setValue(key: string, value: string): boolean {
+        this._tradeParames.set(key, value);
+        return true;
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * 通讯外端列表
+ */
+export enum Transit {
+    /**
+     * 核心后台
+     */
+    CallServer,
+    /**
+     * 平台渠道
+     */
+    CallAgn,
+    /**
+     * 财税平台
+     */
+    CallTips
+}