@gct-paas/render 0.1.4-dev.10

package/es/Event/baseEvent.mjs

@@ -0,0 +1,430 @@
+import { t, INNER_EVENT, FormComponents } from '@gct-paas/core';
+import { useStyleTag } from '@vueuse/core';
+import BigNumberJS from 'bignumber.js';
+import dayjs from 'dayjs';
+import * as _ from 'lodash-es';
+import { differenceBy, cloneDeep } from 'lodash-es';
+import { toRaw } from 'vue';
+import '../utils/field-attrs/basicAttrs.mjs';
+import '@gct-paas/schema';
+import { transformData, transformSourceData } from '../utils/model-transformer.mjs';
+import '../utils/expression/index.mjs';
+import 'qs';
+import { BizService, $httpBizService, $request } from './bizServiceRequest.mjs';
+import { ProcessAppRovedData } from './utils/processRovedInfo.mjs';
+import { Globals } from './utils/runGlobalByPage.mjs';
+import { globalLoading } from './utils/globalLoading.mjs';
+
+class Events {
+  context;
+  searchVNodes;
+  cssData;
+  pageKey;
+  exports;
+  #Oberver;
+  #VNodes;
+  /**流程信息 */
+  ProcessAppRoved;
+  pageLayoutMode;
+  constructor({
+    js,
+    css,
+    pageKey,
+    ContextPc
+  }) {
+    this.cssData = this.#createCss(css);
+    this.searchVNodes = {};
+    this.exports = {};
+    this.#VNodes = {};
+    this.#Oberver = {};
+    this.context = new ContextPc({
+      $ref: this.getComponent.bind(this),
+      $asyncRef: this.getSyncComponent.bind(this)
+    });
+    this.#createFunction(js);
+    Globals.setContextByKey(this.context, pageKey);
+    this.pageKey = pageKey;
+  }
+  /**初始化流程节点信息 */
+  async runProcessBySaskId({
+    taskId,
+    processInstanceId,
+    examineAndApproveState,
+    refFormId
+  }) {
+    this.ProcessAppRoved = new ProcessAppRovedData({
+      taskId,
+      processInstanceId,
+      examineAndApproveState,
+      refFormId
+    });
+    await this.ProcessAppRoved.readyProcess();
+  }
+  #createCss(str, attr = {}) {
+    if (!str) return;
+    const { css, load, unload } = useStyleTag(str, attr);
+    return { css, load, unload };
+  }
+  /**保存所有组件的props*/
+  runContext(key, widget) {
+    this.context.gctWidgets[key] = widget;
+  }
+  /**触发内置事件 */
+  async runEventByName(eventName, events = {}, ...arg) {
+    const E = events[eventName];
+    let data;
+    if (!E) return;
+    if (Array.isArray(E)) {
+      data = await builtInEvents(E, this.context, arg);
+    } else {
+      const fun = this.exports[E.name];
+      if (!fun) throw `函数${E.name}不存在`;
+      data = await fun(...arg, toRaw(E.extraParams));
+    }
+    return data;
+  }
+  /**执行公共函数事件 */
+  async runExportByName(eventName, ...arg) {
+    try {
+      const fun = this.exports[eventName];
+      if (!fun) throw `函数${eventName}不存在`;
+      return fun(...arg);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  /**异步执行公共函数事件 */
+  async runAsyncExportByName(eventName, ...arg) {
+    try {
+      const fun = this.exports[eventName];
+      if (!fun) throw `函数${eventName}不存在`;
+      await this.getReadyByFun(fun);
+      return fun(...arg);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  #createFunction(jsJSON) {
+    if (!jsJSON) return;
+    try {
+      const fun = new Function("exports", "CTX", jsJSON);
+      fun(this.exports, this.context);
+    } catch (error) {
+      console.error(error, "createFunction");
+    }
+  }
+  // 把小组件的实例按照key存起来
+  initNode(key, options) {
+    if (key) {
+      this.#VNodes[key] = options;
+      this.#publish(key, options);
+    }
+  }
+  /**组件销毁 */
+  destroyNode(key) {
+    delete this.#VNodes[key];
+    delete this.#Oberver[key];
+  }
+  // 执行查询
+  initSearchs(key, callback, comId) {
+    if (!key) return;
+    if (this.searchVNodes[key]) {
+      const item = this.searchVNodes[key].find((i) => i.comId === comId);
+      if (item) {
+        item.callback = callback;
+      } else {
+        this.searchVNodes[key].push({ callback, comId });
+      }
+    } else {
+      this.searchVNodes[key] = [{ callback, comId }];
+    }
+  }
+  // 取消注册的查询
+  cancelInitSearchs(key, comId) {
+    if (!key || !this.searchVNodes[key]) return;
+    this.searchVNodes[key] = this.searchVNodes[key].filter(
+      (i) => i.comId !== comId
+    );
+    if (this.searchVNodes[key].length === 0) {
+      delete this.searchVNodes[key];
+    }
+  }
+  runTableBySearch(key, data) {
+    const funArg = this.searchVNodes[key] || [];
+    funArg.forEach(({ callback }) => callback(data));
+  }
+  /**
+   * 组件初始化订阅
+   * @param {*} key 组件唯一key
+   * @param {*} eventName  事件名称
+   */
+  #subscribeready(key, callback) {
+    const options = this.#VNodes[key];
+    if (options) {
+      callback(key, options);
+    } else if (this.#Oberver[key]) {
+      this.#Oberver[key].push(callback);
+    } else {
+      this.#Oberver[key] = [callback];
+    }
+  }
+  /**
+   *
+   * @param key 执行回调
+   */
+  #publish(key, options) {
+    if (this.#Oberver[key]) {
+      this.#Oberver[key].forEach((fun) => {
+        fun(options);
+      });
+    }
+  }
+  /**
+   * 获取组件公用方法 getComponent(identity),根据组件唯一标识获取组件。
+   * @param {*} key
+   * @returns
+   */
+  getComponent(key) {
+    const options = this.#VNodes[key];
+    if (options) {
+      return new GctComponent(key, options);
+    }
+    console.error(key + "组件不存在或者未初始化");
+  }
+  /**
+   * 获取组件公用方法 getComponent(identity),根据组件唯一标识获取组件。
+   * @param {*} key
+   * @returns
+   */
+  getSyncComponent(key) {
+    if (!key) return Promise.reject("标识不能为空");
+    const options = this.#VNodes[key];
+    if (options) {
+      return Promise.resolve(new GctComponent(key, options));
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(key + "不存在或者被隐藏");
+      }, 3e4);
+      this.#subscribeready(key, (options2) => {
+        clearTimeout(timer);
+        resolve(new GctComponent(key, options2));
+      });
+    });
+  }
+  /**
+   * 指定函数中使用到的组件初始化后才执行
+   * @param fun
+   * @returns
+   */
+  async getReadyByFun(fun) {
+    if (typeof fun !== "function") return Promise.reject("参数必须是函数");
+    const funstr = String(fun);
+    const P = funstr.match(/\$ref\((["'A-Za-z0-9_-]+)\)/g)?.map((i) => {
+      const key = i.match(/\$ref\(['|"]([A-Za-z0-9_-]+)['|"]\)/)?.[1];
+      return this.getSyncComponent(key);
+    }) || [];
+    await Promise.all(P);
+  }
+  /**
+   * 流程处理
+   * @param processDateValue
+   * @param data
+   */
+  async processHandle(data, {
+    opinion,
+    reassignId,
+    signature,
+    countersignUserIds,
+    button
+  }) {
+    const { taskId, processInstanceId } = this.ProcessAppRoved;
+    const processData = {
+      procInstId: processInstanceId,
+      data,
+      opinion,
+      button,
+      countersignUserIds,
+      taskId,
+      signature,
+      reassignId
+    };
+    await _gct.api.apaas.pmProcessEngine.postProcExecute(processData);
+  }
+  /**流程审批校验 */
+  async checkedProcess(formProcessId) {
+    const { processId } = this.ProcessAppRoved || {};
+    if (!processId)
+      return Promise.reject(t("sys.process.pleaseInitiateTheProcessFirst"));
+    if (formProcessId !== processId)
+      return Promise.reject(t("sys.process.processInstanceMismatch"));
+  }
+}
+class Context {
+  /**根据key获取当前组件 */
+  $ref;
+  /**根据key异步获取获取组件 */
+  $asyncRef;
+  /**根据id获取模态框 */
+  $getModal;
+  /**关闭当前上下文模态框 */
+  $closeModal;
+  /**调用第三方服务 */
+  $customBizService = BizService;
+  /**组件id和widget 的map */
+  gctWidgets = {};
+  constructor({ $ref, $asyncRef }) {
+    this.$asyncRef = $asyncRef;
+    this.$ref = $ref;
+  }
+  /**ctx 下的工具函数 */
+  $utility = {
+    _,
+    cloneDeep,
+    differenceBy,
+    dayjs,
+    BigNumber: BigNumberJS,
+    plus(a, b) {
+      return new BigNumberJS(a).plus(new BigNumberJS(b)).toNumber();
+    },
+    minus(a, b) {
+      return new BigNumberJS(a).minus(new BigNumberJS(b)).toNumber();
+    },
+    multipliedBy(a, b) {
+      return new BigNumberJS(a).multipliedBy(new BigNumberJS(b)).toNumber();
+    },
+    div(a, b) {
+      return new BigNumberJS(a).div(new BigNumberJS(b)).toNumber();
+    },
+    /**表格数据data,dict翻译 */
+    transformSourceData,
+    /**表单数据data,dict翻译*/
+    transformData
+  };
+  $httpBizService = $httpBizService;
+  $request = $request;
+  /**全局loading */
+  $loading = globalLoading;
+  $getPremission(id) {
+    return Globals.getPremission(id);
+  }
+  /**
+   *
+   * @param key 组件权限标识
+   * @param id 组件id
+   */
+  $setPremission(key, id) {
+    Globals.setPremission(key, id);
+  }
+  /**获取应用全局变量 */
+  $getAppGlobalVar(id) {
+    return Globals.getGlobalVar(id);
+  }
+  /**设置应用全局变量 */
+  $setAppGlobalVar(id, value) {
+    Globals.setGlobalVar(id, value);
+  }
+  /**获取页面全局变量老版本兼容问题暂时不删除 后续不维护*/
+  $getPageGlobalVar(id) {
+    return Globals.getPageGlobalVar(id);
+  }
+  /**设置页面变量老版本 兼容问题暂时不删除 后续不维护 */
+  $setPageGlobalVar(id, value) {
+    Globals.setPageGlobalVar(id, value);
+  }
+  /**获取页面全局变量 */
+  $getPageVar(id) {
+    return Globals.getPageVar(id);
+  }
+  /**设置页面全局变量 */
+  $setPageVar(id, value) {
+    Globals.setPageVar(id, value);
+  }
+  /**根据模态框id 获取上下文 id不传默认页面上下文*/
+  $getCtxById(modalKey) {
+    return Globals.getContextByKey(modalKey);
+  }
+  /**设置组件的属性 */
+  $setPropsByKey(key, fromProp) {
+    const toProps = this.gctWidgets[key]?.props;
+    if (!toProps) return;
+    for (const k in fromProp) {
+      toProps[k] = fromProp[k];
+    }
+  }
+  /**获取组件的属性 */
+  $getPropsByKey(key, PropsKey = [], root) {
+    const widget = this.gctWidgets[key];
+    if (!widget) return {};
+    const props = root || !widget.props ? widget : widget.props;
+    if (typeof PropsKey === "string") {
+      PropsKey = [PropsKey];
+    }
+    return PropsKey.reduce((pre, curr) => {
+      pre[curr] = props[curr];
+      return pre;
+    }, {});
+  }
+}
+class GctComponent {
+  modelKey;
+  getValue;
+  setValue;
+  /**提交 */
+  submit;
+  /**刷新 */
+  reload;
+  key;
+  constructor(key, options) {
+    this.key = key;
+    const elRef = options.elRef;
+    Object.keys(elRef).forEach((k) => {
+      this[k] = elRef[k];
+    });
+  }
+}
+async function builtInEvents(eventList, context, args) {
+  const allEvent = eventList.map(transformEventFun.bind(context, args));
+  await Promise.all(allEvent);
+}
+async function transformEventFun(args, item) {
+  const { name, refId, scopeId, modalTitle } = item;
+  const ids = modalTitle?.split(".") || [];
+  let widget;
+  if (ids.length > 1) {
+    const orgWidget = this.gctWidgets?.[ids[0]] || {};
+    const opes = [];
+    getAllOpe(opes, orgWidget);
+    widget = opes.find((i) => i.id === ids[1]) || {};
+  } else if (ids.length) {
+    widget = this.gctWidgets?.[ids[0]];
+  }
+  if (name === INNER_EVENT.OPEN_MODAL) {
+    await this.$getModal(refId).open({ title: widget?.props?.title });
+  }
+  if (name === INNER_EVENT.CLOSE_MODAL) {
+    if (refId) {
+      await this.$getModal(refId).close();
+    } else {
+      await this.$closeModal();
+    }
+  }
+  if (name === INNER_EVENT.REFRESH_TABLE) {
+    const com = await this.$getCtxById(scopeId).$asyncRef(refId);
+    await com.reload(args ? args[0] : null);
+  }
+}
+function getAllOpe(arr, widget) {
+  const children = widget.children || [];
+  for (const i of children) {
+    if (i.type && i.type == FormComponents.CustomButton) {
+      arr.push(i);
+    } else {
+      if (i.children?.length) {
+        getAllOpe(arr, i);
+      }
+    }
+  }
+}
+
+export { Context, Events, GctComponent };

package/es/Event/bizServiceRequest.d.ts

@@ -0,0 +1,26 @@
+import { BizServiceEnum, EntityModelCategoryEnum } from '@gct-paas/core';
+import { AxiosRequestConfig } from 'axios';
+export declare const BizService: {
+    post: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+    get: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+    put: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+    delete: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+};
+/**
+ * 系统内置业务服务请求
+ * @param path
+ * @param params
+ * @param config
+ * @returns
+ */
+export declare function $httpBizService(path: PathType, params: Record<string, unknown>, config?: AxiosRequestConfig): Promise<unknown>;
+/**post 业务服务请求 */
+export declare function $request(modelKey: string, action: PathType['action'], { body, query }?: IObject, config?: AxiosRequestConfig): Promise<unknown>;
+type BizServiceParams = Record<string, unknown>;
+export interface PathType {
+    key: string;
+    action: keyof typeof BizServiceEnum;
+    modelCategory?: EntityModelCategoryEnum;
+}
+export type BizServiceMethod = (path: PathType, params: BizServiceParams, ...args: unknown[]) => Promise<unknown>;
+export {};

package/es/Event/bizServiceRequest.mjs

@@ -0,0 +1,47 @@
+import { EntityModelCategoryEnum, BizServiceEnum } from '@gct-paas/core';
+
+const bizServiceRequestHook = (api) => (path, query = {}, data = {}, config = {}) => {
+  return api(
+    {
+      modelKey: path.key,
+      bsKey: path.action,
+      modelCategory: path.modelCategory ?? EntityModelCategoryEnum.ENTITY
+    },
+    query,
+    data,
+    config
+  );
+};
+const BizService = {
+  post: bizServiceRequestHook(
+    _gct.api.apaas.modelComprehensive.postBizServiceModelCategoryModelKeyBsKey
+  ),
+  get: bizServiceRequestHook(
+    _gct.api.apaas.modelComprehensive.getBizServiceModelCategoryModelKeyBsKey
+  ),
+  put: bizServiceRequestHook(
+    _gct.api.apaas.modelComprehensive.putBizServiceModelCategoryModelKeyBsKey
+  ),
+  delete: bizServiceRequestHook(
+    _gct.api.apaas.modelComprehensive.deleteBizServiceModelCategoryModelKeyBsKey
+  )
+};
+async function $httpBizService(path, params, config = {}) {
+  const method = BizServiceEnum[path.action];
+  return BizService[method](path, params, config);
+}
+async function $request(modelKey, action, { body = {}, query = {} } = {}, config = {}) {
+  const res = await _gct.api.apaas.modelComprehensive.postBizServiceGeneralModelCategoryModelKeyBsKey(
+    {
+      bsKey: action,
+      modelKey,
+      modelCategory: EntityModelCategoryEnum.ENTITY
+    },
+    query,
+    body,
+    config
+  );
+  return res;
+}
+
+export { $httpBizService, $request, BizService };

package/es/Event/eventType.d.ts

@@ -0,0 +1,20 @@
+import { FormComponents, ButtonTypeEnum } from '@gct-paas/core';
+export interface InitNodeOptions {
+    /**组件方法 */
+    elRef: Record<string, FunctionType> | null;
+    /**组件类型 */
+    type: FormComponents;
+}
+export interface EventsConstructor {
+    js: string;
+    css: string;
+    pageKey?: string;
+}
+export interface processDateValue {
+    bizServiceKey: string;
+    button: ButtonTypeEnum;
+    message?: string;
+    processInstanceId?: string;
+    processKey: string;
+}
+export type FunctionType = (...arg: unknown[]) => unknown;

package/es/Event/index.d.ts

@@ -0,0 +1,4 @@
+export { Globals, pageGlobaVariables, globalVarCaches, formMap, setFormData, pageDataforJson, getPageTitle, getPremission, } from './utils/runGlobalByPage';
+export { Events, Context, GctComponent } from './baseEvent';
+export { type EventsConstructor } from './eventType';
+export * from './Dependency/useDependencyToShow';

package/es/Event/utils/appRedis.d.ts

@@ -0,0 +1,29 @@
+import { UserLoginResp } from '@gct-paas/api/platform';
+export declare class GlobaAppInfo {
+    /**环境变量 */
+    static ENV: string;
+    /**应用标识 */
+    static AID: string;
+    /**用户信息 */
+    static userInfo: UserLoginResp;
+    /**app初始化变量 */
+    static runApp({ userInfo, env, aid }: RunAppParams): void;
+}
+/**获取缓存变量 */
+export declare const useCreateAppredis: <T = unknown>({ value: defaultValue, appredis, key: varKey, type, }: UseCreateAppredisOptions<T>) => GlobalVar<T>;
+interface RunAppParams {
+    env: string;
+    aid: string;
+    userInfo: UserLoginResp;
+}
+interface GlobalVar<T = unknown> {
+    value: T;
+    type: unknown;
+}
+export interface UseCreateAppredisOptions<T = unknown> {
+    value: T;
+    appredis: boolean;
+    key: string;
+    type: unknown;
+}
+export {};

package/es/Event/utils/appRedis.mjs

@@ -0,0 +1,50 @@
+import { useGctSelect } from '../../hooks/useStorageRef.mjs';
+
+class GlobaAppInfo {
+  /**环境变量 */
+  static ENV;
+  /**应用标识 */
+  static AID;
+  /**用户信息 */
+  static userInfo;
+  /**app初始化变量 */
+  static runApp({ userInfo, env, aid }) {
+    this.ENV = env;
+    this.AID = aid;
+    this.userInfo = userInfo;
+  }
+}
+const useCreateAppredis = ({
+  value: defaultValue,
+  appredis,
+  key: varKey,
+  type
+}) => {
+  const isredis = GlobaAppInfo.ENV !== "dev" ? appredis : false;
+  const key = `${GlobaAppInfo.AID}_${GlobaAppInfo.userInfo?.userId}`;
+  const { cacheMap } = useGctSelect(key);
+  const globalVar = new Proxy(
+    { value: defaultValue, type },
+    {
+      get(target, name) {
+        if (isredis && name === "value") {
+          return cacheMap.value[varKey];
+        }
+        return Reflect.get(target, name);
+      },
+      set(target, name, value, receiver) {
+        if (isredis && name === "value") {
+          if (cacheMap.value[varKey]) {
+            cacheMap.value[varKey] = value;
+          } else {
+            cacheMap.value = { ...cacheMap.value, [varKey]: value };
+          }
+        }
+        return Reflect.set(target, name, value, receiver);
+      }
+    }
+  );
+  return globalVar;
+};
+
+export { GlobaAppInfo, useCreateAppredis };

package/es/Event/utils/globalLoading.d.ts

@@ -0,0 +1,13 @@
+declare class GlobalLoading {
+    static instance: GlobalLoading;
+    mask: HTMLDivElement;
+    container: HTMLDivElement;
+    spinner: HTMLDivElement;
+    constructor();
+    createLoadingElement(): void;
+    initStyle(): void;
+    show(): void;
+    hide(): void;
+}
+export declare const globalLoading: GlobalLoading;
+export {};