@ibiz-template/model-helper 0.7.41-alpha.11 → 0.7.41-alpha.111

package/src/utils/merge-model/merge-treeview.ts

@@ -0,0 +1,197 @@
+/* eslint-disable no-case-declarations */
+import { IDETree, IDETreeNodeRS } from '@ibiz/model-core';
+
+/**
+ * 合并树部件
+ *
+ * @author tony001
+ * @date 2024-09-26 17:09:25
+ * @export
+ * @param {IDETree} dst
+ * @param {IDETree} source
+ */
+export function mergeTreeView(dst: IDETree, source: IDETree): void {
+  if (!dst || !source) return;
+  // 合并树节点
+  if (source.detreeNodes && source.detreeNodes.length > 0) {
+    if (!dst.detreeNodes) {
+      dst.detreeNodes = [];
+    }
+    source.detreeNodes.forEach(sourceNode => {
+      const item = dst.detreeNodes!.find(dstNode => {
+        return dstNode.id === sourceNode.id;
+      });
+      if (!item) {
+        dst.detreeNodes?.push(sourceNode);
+      }
+    });
+  }
+  // 合并树节点关系
+  if (source.detreeNodeRSs && source.detreeNodeRSs.length > 0) {
+    if (!dst.detreeNodeRSs) {
+      dst.detreeNodeRSs = [];
+    }
+    source.detreeNodeRSs.forEach(sourceNodeRs => {
+      // 若配置了用户标记（dynamic_overlay:before|after|replace|delete|start|end:noderesid），则需根据用户标记进行合并，否则原始数据没有则直接附加末尾
+      if (
+        (sourceNodeRs as IModel).userTag &&
+        (sourceNodeRs as IModel).userTag.startsWith('dynamic_overlay') &&
+        (sourceNodeRs as IModel).userTag.split(':').length === 3
+      ) {
+        mergeSubAppTreeNodeResToDst(dst, sourceNodeRs);
+      } else {
+        const itemIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+          return (
+            dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId &&
+            dstNodeRs.childDETreeNodeId === sourceNodeRs.childDETreeNodeId
+          );
+        });
+        // 若存在end标记，则需要添加到第一个end标记节点关系前面，保证end标记节点关系始终添加到最后
+        const endIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+          if (
+            dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+          ) {
+            const tags = (sourceNodeRs as IModel).userTag?.split(':');
+            if (!tags || tags.length !== 3 || tags[1] !== 'end') return false;
+            return true;
+          }
+          return false;
+        });
+        if (itemIndex === -1) {
+          if (endIndex === -1) {
+            dst.detreeNodeRSs?.push(sourceNodeRs);
+          } else {
+            dst.detreeNodeRSs!.splice(endIndex, 0, sourceNodeRs);
+          }
+        }
+      }
+    });
+  }
+}
+
+/**
+ * 合并指定子应用树节点关系到主应用树指定位置
+ * @param dst 原始树
+ * @param sourceNode 子应用树节点关系
+ */
+function mergeSubAppTreeNodeResToDst(
+  dst: IDETree,
+  sourceNodeRs: IDETreeNodeRS,
+): void {
+  // dynamic_overlay:before|after|replace|delete|start|end:nodeid 定义附加位置
+  const [dynamicOverlay, targetPosition, targetTag] = (
+    sourceNodeRs as IModel
+  ).userTag.split(':');
+  if (!dynamicOverlay || !targetPosition || !targetTag) return;
+  switch (targetPosition) {
+    case 'before':
+      // 在目标节点之前,dynamic_overlay:before:childnodeid,这儿最后一节拼接的是子节点标识
+      const beforeIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (beforeIndex !== -1) {
+        dst.detreeNodeRSs!.splice(beforeIndex, 0, sourceNodeRs);
+      }
+      break;
+    case 'after':
+      // 在目标节点之后,格式如：dynamic_overlay:after:childnodeid,最后一节拼接的是子节点标识
+      const afterIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (afterIndex !== -1) {
+        dst.detreeNodeRSs!.splice(afterIndex + 1, 0, sourceNodeRs);
+      }
+      break;
+    case 'replace':
+      // 替换目标节点,格式如：dynamic_overlay:replace:childnodeid,最后一节拼接的是子节点标识
+      const replaceIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (replaceIndex !== -1) {
+        dst.detreeNodeRSs!.splice(replaceIndex, 1, sourceNodeRs);
+      }
+      break;
+    case 'delete':
+      // 删除目标节点,格式如：dynamic_overlay:delete:childnodeid,最后一节拼接的是子节点标识
+      const deleteIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return (
+          dstNode.childDETreeNodeId === targetTag &&
+          dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId
+        );
+      });
+      if (deleteIndex !== -1) {
+        dst.detreeNodeRSs!.splice(deleteIndex, 1);
+      }
+      break;
+    case 'start':
+      // 在目标节点内部开始，格式如：dynamic_overlay:start:随机字符,最后一节拼接的是随机字符，读的是当前节点关系的父节点标识
+      const startIndex = dst.detreeNodeRSs!.findIndex(dstNode => {
+        return dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId;
+      });
+      if (startIndex !== -1) {
+        dst.detreeNodeRSs!.splice(startIndex, 0, sourceNodeRs);
+      }
+      break;
+    case 'end':
+      // 在目标节点内部结束，格式如：dynamic_overlay:end:随机字符,最后一节拼接的是随机字符，读的是当前节点关系的父节点标识
+      const endIndex = getLastIndex(dst.detreeNodeRSs!, dstNode => {
+        return dstNode.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId;
+      });
+      if (endIndex !== -1) {
+        dst.detreeNodeRSs!.splice(endIndex + 1, 0, sourceNodeRs);
+      }
+      break;
+    default:
+      // 未识别位置，若源树不存在该关系，则直接附加到最后
+      const defaultIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+        return (
+          dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId &&
+          dstNodeRs.childDETreeNodeId === sourceNodeRs.childDETreeNodeId
+        );
+      });
+      // 若存在end标记，则需要添加到第一个end标记节点关系前面，保证end标记节点关系始终添加到最后
+      const defaultEndIndex = dst.detreeNodeRSs!.findIndex(dstNodeRs => {
+        if (dstNodeRs.parentDETreeNodeId === sourceNodeRs.parentDETreeNodeId) {
+          const tags = (sourceNodeRs as IModel).userTag?.split(':');
+          if (!tags || tags.length !== 3 || tags[1] !== 'end') return false;
+          return true;
+        }
+        return false;
+      });
+      if (defaultIndex === -1) {
+        if (defaultEndIndex === -1) {
+          dst.detreeNodeRSs?.push(sourceNodeRs);
+        } else {
+          dst.detreeNodeRSs!.splice(defaultEndIndex, 0, sourceNodeRs);
+        }
+      }
+      break;
+  }
+}
+
+/**
+ * 获取指定数组中满足条件的最后一个元素
+ * @param arr 指定数组
+ * @param predicate 过滤条件
+ * @returns 找到则返回指定元素下标，反之返回-1
+ */
+function getLastIndex(
+  arr: IModel[],
+  predicate: (item: IModel) => boolean,
+): number {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i])) {
+      return i;
+    }
+  }
+  return -1;
+}

package/src/utils/plural/plural.ts

@@ -0,0 +1,30 @@
+import pluralize from 'pluralize';
+
+// 补充特殊转换规则
+pluralize.addPluralRule(/(matr|vert|ind)ix|ex$/, '$1ices');
+
+/**
+ * 英文转复数写法
+ *
+ * @author chitanda
+ * @date 2022-08-25 18:08:41
+ * @export
+ * @param {string} key
+ * @return {*}  {string}
+ */
+export function plural(key: string): string {
+  return pluralize(key);
+}
+
+/**
+ * 英文转复数写法并转全小写
+ *
+ * @author chitanda
+ * @date 2022-08-25 18:08:23
+ * @export
+ * @param {string} key
+ * @return {*}  {string}
+ */
+export function pluralLower(key: string): string {
+  return plural(key).toLowerCase();
+}

package/src/utils/service-path-util/service-path-util.ts

@@ -0,0 +1,361 @@
+import { IAppDERS, IApplication } from '@ibiz/model-core';
+import { plural } from '../plural/plural';
+import { ModelUtil } from '../../model-util';
+
+/**
+ * 获取服务拼接递归对象
+ */
+export type ServicePathDeep = [IAppDERS, ServicePathDeep[]];
+
+/**
+ * 服务路径项
+ */
+export type ServicePathItem = {
+  /**
+   * 实体代码名称(标准)
+   *
+   * @author chitanda
+   * @date 2022-08-25 18:08:35
+   * @type {string}
+   */
+  codeName: string;
+  /**
+   * 实体代码名称(小写)
+   *
+   * @author chitanda
+   * @date 2022-08-25 18:08:54
+   * @type {string}
+   */
+  lower: string;
+  /**
+   * 实体代码名称复数(小写)
+   *
+   * @author chitanda
+   * @date 2022-08-25 18:08:13
+   * @type {string}
+   */
+  plural: string;
+};
+
+/**
+ * 服务接口项
+ */
+export type ServiceApiItem = {
+  /**
+   * 实体代码名称(标准)
+   *
+   * @author tony001
+   * @date 2024-05-11 15:05:54
+   * @type {string}
+   */
+  codeName: string;
+
+  /**
+   * 实体服务接口代码标识
+   *
+   * @author tony001
+   * @date 2024-05-11 15:05:43
+   * @type {string}
+   */
+  deApiCodeName: string;
+
+  /**
+   * 实体服务接口代码标识2（复数）
+   *
+   * @author tony001
+   * @date 2024-05-11 15:05:43
+   * @type {string}
+   */
+  deApiCodeName2: string;
+};
+
+/**
+ * 服务路径拼接工具
+ *
+ * @author chitanda
+ * @date 2022-08-22 21:08:52
+ * @export
+ * @class ServicePathUtil
+ */
+export class ServicePathUtil {
+  /**
+   * 应用实体关系
+   *
+   * @author chitanda
+   * @date 2022-08-22 22:08:18
+   * @protected
+   * @type {Map<string, IAppDERS[]>} <应用实体 id, 应用实体父关系>
+   */
+  protected entityRsMap: Map<string, IAppDERS[]> = new Map();
+
+  /**
+   * 实体资源路径
+   *
+   * @author chitanda
+   * @date 2022-08-22 22:08:58
+   * @protected
+   * @type {Map<string, ServicePathItem[][]>}
+   */
+  protected entityRsPathMap: Map<string, ServicePathItem[][]> = new Map();
+
+  /**
+   * 实体资源加载状态关系
+   *
+   * @author tony001
+   * @date 2024-05-20 16:05:41
+   * @protected
+   * @type {Map<string, boolean>}
+   */
+  protected entityRsLoadMap: Map<string, boolean> = new Map();
+
+  constructor(
+    protected appDataEntities: IModel[],
+    protected allDERss: IAppDERS[],
+    protected modelUtil: ModelUtil,
+  ) {}
+
+  /**
+   * 根据应用主实体过滤从关系集合
+   *
+   * @author chitanda
+   * @date 2023-04-20 17:04:34
+   * @protected
+   * @param {string} id
+   * @return {*}  {IAppDERS[]}
+   */
+  protected filterDERSs(id: string): IAppDERS[] {
+    if (this.entityRsMap.has(id)) {
+      return this.entityRsMap.get(id)!;
+    }
+    const items = this.allDERss.filter(item => {
+      if ((item as IModel).rSMode === 2 && item.minorAppDataEntityId === id) {
+        return item;
+      }
+      return null;
+    });
+    if (items.length > 0) {
+      this.entityRsMap.set(id, items);
+    }
+    return items;
+  }
+
+  /**
+   * 计算指定应用实体所有资源路径
+   *
+   * @author chitanda
+   * @date 2023-04-22 13:04:27
+   * @param {string} id
+   * @return {*}  {string[]}
+   */
+  async calcRequestPaths(id: string): Promise<string[]> {
+    const paths = await this.calcPaths(id);
+    return paths.map(path => {
+      return path.map(item => `${item.plural}/\${${item.lower}}`).join('/');
+    });
+  }
+
+  /**
+   * 计算指定实体所有资源路径
+   *
+   * @author chitanda
+   * @date 2023-04-22 13:04:36
+   * @protected
+   * @param {string} id
+   * @return {*}  {ServicePathItem[][]} 返回顺序为 [祖父实体，爷爷实体，父实体，当前实体]
+   */
+  protected async calcPaths(id: string): Promise<ServicePathItem[][]> {
+    const entityRef = this.appDataEntities.find(item => item.id === id);
+    if (!entityRef) {
+      throw new Error(ibiz.i18n.t('modelHelper.utils.noFoundEntity', { id }));
+    }
+    const { codeName } = entityRef;
+    if (!this.entityRsLoadMap.has(codeName)) {
+      this.entityRsLoadMap.set(codeName, false);
+    }
+    // 需要处理完成才能获取
+    if (
+      this.entityRsPathMap.has(codeName) &&
+      this.entityRsLoadMap.get(codeName)
+    ) {
+      return this.entityRsPathMap.get(codeName)!;
+    }
+    const deRss = this.filterDERSs(id);
+    if (deRss) {
+      // 已经计算过的应用实体标识
+      const ids: string[] = [id];
+      const arr = this.calcDeepPath(ids, deRss);
+      await this.deepFillPath(codeName, [codeName], arr);
+      let paths = this.entityRsPathMap.get(codeName);
+      if (paths) {
+        paths = this.sortPath(paths);
+        this.entityRsPathMap.set(codeName, paths);
+        this.entityRsLoadMap.set(codeName, true);
+        return paths;
+      }
+    }
+    this.entityRsLoadMap.set(codeName, true);
+    return [];
+  }
+
+  /**
+   * 计算递归资源路径
+   *
+   * @author chitanda
+   * @date 2023-08-23 14:08:39
+   * @protected
+   * @param {string[]} ids
+   * @param {IAppDERS[]} deRss
+   * @param {number} [num=0]
+   * @return {*}  {ServicePathDeep[]}
+   */
+  protected calcDeepPath(
+    ids: string[],
+    deRss: IAppDERS[],
+    num: number = 0,
+  ): ServicePathDeep[] {
+    if (num > 10) {
+      throw new Error(ibiz.i18n.t('modelHelper.utils.maximumTier'));
+    }
+    num += 1;
+    const arr: ServicePathDeep[] = [];
+    deRss.forEach(rs => {
+      if (ids.includes(rs.majorAppDataEntityId!)) {
+        ibiz.log.warn(
+          ibiz.i18n.t('modelHelper.utils.circularRecursive'),
+          rs.majorAppDataEntityId,
+          ibiz.i18n.t('modelHelper.utils.calculatedEntities'),
+          ids,
+        );
+        return;
+      }
+      const items = this.filterDERSs(rs.majorAppDataEntityId!);
+      arr.push([
+        rs,
+        this.calcDeepPath([...ids, rs.majorAppDataEntityId!], items, num),
+      ]);
+    });
+    return arr;
+  }
+
+  /**
+   * 递归填充计算所有资源路径
+   *
+   * @author chitanda
+   * @date 2022-08-22 22:08:04
+   * @protected
+   * @param {string} deCodeName
+   * @param {string[]} pathNames
+   * @param {ServicePathDeep[]} items
+   */
+  protected async deepFillPath(
+    deCodeName: string,
+    pathNames: string[],
+    items: ServicePathDeep[],
+  ): Promise<void> {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const [rs, children] = item;
+      if (children.length > 0) {
+        await this.deepFillPath(
+          deCodeName,
+          [...pathNames, rs.majorDECodeName!],
+          children,
+        );
+      }
+      if (!this.entityRsPathMap.has(deCodeName)) {
+        this.entityRsPathMap.set(deCodeName, []);
+      }
+      const arr = this.entityRsPathMap.get(deCodeName)!;
+
+      const serviceApiItems = await this.getServiceApiItems(pathNames);
+      const rsServiceApiItems = await this.getServiceApiItems([
+        rs.majorDECodeName!,
+      ]);
+      const tempArr = [
+        ...pathNames.map((pathName, index) => {
+          return {
+            codeName: pathName,
+            lower: pathName.toLowerCase(),
+            plural: serviceApiItems[index].deApiCodeName2,
+          };
+        }),
+        {
+          codeName: rs.majorDECodeName!,
+          lower: rs.majorDECodeName!.toLowerCase(),
+          plural: rsServiceApiItems[0].deApiCodeName2,
+        },
+      ].reverse();
+      const targetIndex = arr.findIndex(ele => {
+        return (
+          ele
+            .map(val => {
+              return val.codeName;
+            })
+            .join('/') ===
+          tempArr
+            .map(temp => {
+              return temp.codeName;
+            })
+            .join('/')
+        );
+      });
+      if (targetIndex === -1) {
+        arr.push(tempArr);
+      }
+    }
+  }
+
+  /**
+   * 排序资源路径顺序
+   *
+   * @author chitanda
+   * @date 2022-08-22 22:08:44
+   * @protected
+   * @param {ServicePathItem[][]} paths
+   * @return {*}  {ServicePathItem[][]}
+   */
+  protected sortPath(paths: ServicePathItem[][]): ServicePathItem[][] {
+    return paths.sort((a, b) => {
+      return b.length - a.length;
+    });
+  }
+
+  /**
+   * 通过codeName数据获取相关接口标识数据
+   *
+   * @author tony001
+   * @date 2024-05-11 17:05:51
+   * @protected
+   * @param {string[]} codeNames
+   * @return {*}  {Promise<ServiceApiItem[]>}
+   */
+  protected async getServiceApiItems(
+    codeNames: string[],
+  ): Promise<ServiceApiItem[]> {
+    const serviceApiItems: ServiceApiItem[] = [];
+    for (let i = 0; i < codeNames.length; i++) {
+      const appEntity = await this.modelUtil.getAppDataEntityModel(
+        codeNames[i],
+        false,
+      );
+      const serviceApiItem: ServiceApiItem = {
+        codeName: codeNames[i],
+        deApiCodeName: appEntity.dEAPICodeName,
+        deApiCodeName2: '',
+      };
+      if (appEntity.dEAPICodeName) {
+        if (!appEntity.deapicodeName2) {
+          serviceApiItem.deApiCodeName2 = plural(appEntity.dEAPICodeName);
+        }
+        const { engineVer } =
+          (await this.modelUtil.getAppModel()) as IApplication;
+        if (!engineVer || engineVer < 240) {
+          serviceApiItem.deApiCodeName2 =
+            appEntity.deapicodeName2!.toLowerCase();
+        }
+      }
+      serviceApiItems.push(serviceApiItem);
+    }
+    return serviceApiItems;
+  }
+}