From cdd886bfcd027889d2d68713e1cb556e3546290f Mon Sep 17 00:00:00 2001
From: snowgitea <haoyuexc100@outlook.com>
Date: Wed, 1 Jul 2026 17:56:46 +0800
Subject: [PATCH] chore: src/modules/dict/service/info.ts

---
 src/modules/dict/service/info.ts | 146 +++++++++++++++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 src/modules/dict/service/info.ts

diff --git a/src/modules/dict/service/info.ts b/src/modules/dict/service/info.ts
new file mode 100644
index 0000000..9be106c
--- /dev/null
+++ b/src/modules/dict/service/info.ts
@@ -0,0 +1,146 @@
+import { DictTypeEntity } from './../entity/type';
+import { DictInfoEntity } from './../entity/info';
+import { Config, Provide } from '@midwayjs/core';
+import { BaseService } from '@cool-midway/core';
+import { InjectEntityModel } from '@midwayjs/typeorm';
+import { Repository, In } from 'typeorm';
+import * as _ from 'lodash';
+
+/**
+ * 字典信息
+ */
+@Provide()
+export class DictInfoService extends BaseService {
+  @InjectEntityModel(DictInfoEntity)
+  dictInfoEntity: Repository<DictInfoEntity>;
+
+  @InjectEntityModel(DictTypeEntity)
+  dictTypeEntity: Repository<DictTypeEntity>;
+
+  @Config('typeorm.dataSource.default.type')
+  ormType: string;
+
+  /**
+   * 获得字典数据
+   * @param types
+   */
+  async data(types: string[]) {
+    const result = {};
+    let typeData = await this.dictTypeEntity.find();
+    if (!_.isEmpty(types)) {
+      typeData = await this.dictTypeEntity.findBy({ key: In(types) });
+    }
+    if (_.isEmpty(typeData)) {
+      return {};
+    }
+    const data = await this.dictInfoEntity
+      .createQueryBuilder('a')
+      .select([
+        'a.id',
+        'a.name',
+        'a.typeId',
+        'a.parentId',
+        'a.orderNum',
+        'a.value',
+      ])
+      .where('a.typeId in(:...typeIds)', {
+        typeIds: typeData.map(e => {
+          return e.id;
+        }),
+      })
+      .orderBy('a.orderNum', 'ASC')
+      .addOrderBy('a.createTime', 'ASC')
+      .getMany();
+    for (const item of typeData) {
+      result[item.key] = _.filter(data, { typeId: item.id }).map(e => {
+        const value = e.value ? Number(e.value) : e.value;
+        return {
+          ...e,
+          // @ts-ignore
+          value: isNaN(value) ? e.value : value,
+        };
+      });
+    }
+    return result;
+  }
+
+  /**
+   * 获得字典key
+   * @returns
+   */
+  async types() {
+    return await this.dictTypeEntity.find();
+  }
+
+  /**
+   * 获得单个或多个字典值
+   * @param value 字典值或字典值数组
+   * @param key 字典类型
+   * @returns
+   */
+  async getValues(value: string | string[], key: string) {
+    // 获取字典类型
+    const type = await this.dictTypeEntity.findOneBy({ key });
+    if (!type) {
+      return null; // 或者适当的错误处理
+    }
+
+    // 根据typeId获取所有相关的字典信息
+    const dictValues = await this.dictInfoEntity.find({
+      where: { typeId: type.id },
+    });
+
+    // 如果value是字符串，直接查找
+    if (typeof value === 'string') {
+      return this.findValueInDictValues(value, dictValues);
+    }
+
+    // 如果value是数组，遍历数组，对每个元素进行查找
+    return value.map(val => this.findValueInDictValues(val, dictValues));
+  }
+
+  /**
+   * 在字典值数组中查找指定的值
+   * @param value 要查找的值
+   * @param dictValues 字典值数组
+   * @returns
+   */
+  findValueInDictValues(value: string, dictValues: any[]) {
+    let result = dictValues.find(dictValue => dictValue.value === value);
+    if (!result) {
+      result = dictValues.find(dictValue => dictValue.id === parseInt(value));
+    }
+    return result ? result.name : null; // 或者适当的错误处理
+  }
+
+  /**
+   * 修改之后
+   * @param data
+   * @param type
+   */
+  async modifyAfter(data: any, type: 'delete' | 'update' | 'add') {
+    if (type === 'delete') {
+      for (const id of data) {
+        await this.delChildDict(id);
+      }
+    }
+  }
+
+  /**
+   * 删除子字典
+   * @param id
+   */
+  private async delChildDict(id) {
+    const delDict = await this.dictInfoEntity.findBy({ parentId: id });
+    if (_.isEmpty(delDict)) {
+      return;
+    }
+    const delDictIds = delDict.map(e => {
+      return e.id;
+    });
+    await this.dictInfoEntity.delete(delDictIds);
+    for (const dictId of delDictIds) {
+      await this.delChildDict(dictId);
+    }
+  }
+}