fix: 对接字典

zhengyiming

3 天以前 dd0a3e0ed394983c4fbacdab64cad6f8de5b4884

fix: 对接字典

 apps/bMiniApp/src/pages/home/HomeQueryMenuView.vue

@@ -5,7 +5,7 @@
        <ProRadio v-model="query.gender" :value-enum="GenderText" show-all-btn></ProRadio>
      </QueryMenuItem>
      <QueryMenuItem title="身份">
        <ProRadio v-model="query.gender" :value-enum="IdentityList" show-all-btn></ProRadio>
        <ProRadio v-model="query.identity" :value-enum="identityList" show-all-btn></ProRadio>
      </QueryMenuItem>
      <QueryMenuItem>
        <template #title>
@@ -23,7 +23,11 @@
        ></nut-range>
      </QueryMenuItem>
      <QueryMenuItem title="资格证书">
        <ProRadio v-model="query.gender" :value-enum="CertificateTypeList" show-all-btn></ProRadio>
        <ProRadio
          v-model="query.certificateType"
          :value-enum="certificateTypeList"
          show-all-btn
        ></ProRadio>
      </QueryMenuItem>
    </div>
  </QueryMenuView>
@@ -31,8 +35,8 @@

<script setup lang="ts">
import { QueryMenuView, QueryMenuItem, ProRadio } from '@12333/components';
import { GenderText, SearchType } from '@12333/constants';
import { useSearchSettingType } from '@12333/hooks';
import { GenderText, CategoryCode } from '@12333/constants';
import { useDictionaryDataSelect } from '@12333/hooks';

defineOptions({
  name: 'HomeQueryMenuView',
@@ -42,11 +46,12 @@

// const props = withDefaults(defineProps<Props>(), {});

const { searchSettingTypeList: CertificateTypeList } = useSearchSettingType({
  searchType: SearchType.CertificateType,
const { dictionaryDataList: identityList } = useDictionaryDataSelect({
  categoryCode: CategoryCode.Identity,
});
const { searchSettingTypeList: IdentityList } = useSearchSettingType({
  searchType: SearchType.Identity,

const { dictionaryDataList: certificateTypeList } = useDictionaryDataSelect({
  categoryCode: CategoryCode.CertificateType,
});

const emit = defineEmits<{
@@ -57,13 +62,14 @@
const query = defineModel<{
  gender: number | string;
  age: number[];
  identity: string;
  certificateType: string;
}>('query');

const DefaultQuery = {
  ...query.value,
};

console.log('query: ', query.value);
function handleReset() {
  for (const key in DefaultQuery) {
    query.value[key] = DefaultQuery[key];

 apps/bMiniApp/src/pages/home/HomeQueryPositionMenuView.vue

@@ -24,7 +24,7 @@
}>();

const query = defineModel<{
  position: any[];
  position: string[];
}>('query');

const DefaultQuery = {

 apps/bMiniApp/src/pages/home/index.vue

@@ -89,10 +89,12 @@
const queryMenuState = reactive({
  gender: '' as any as Gender,
  age: [15, 65],
  identity: '',
  certificateType: '',
});

const queryPositionState = reactive({
  position: [],
  position: [] as string[],
});

const queryState = reactive({

 apps/bMiniApp/src/subpackages/task/publishTask/InnerPage.vue

@@ -161,12 +161,8 @@
const isCopy = router.params?.isCopy === 'true';
console.log('isCopy: ', router.params?.isCopy);

const { searchSettingTypeList: WelfareTypeList } = useSearchSettingType({
  searchType: SearchType.Welfare,
});
const { searchSettingTypeList: CertificateTypeList } = useSearchSettingType({
  searchType: SearchType.CertificateType,
});
const WelfareTypeList = ref([]);
const CertificateTypeList = ref([]);

const form = reactive({
  taskName: '',

 packages/components/src/AreaTreeSelect/PositionSelectView.vue

@@ -1,16 +1,16 @@
<template>
  <Category :category="industryList" @change="change" class="position-select-view">
  <Category :category="_industryList" @change="change" class="position-select-view">
    <CategoryPane :max="max" :categoryChild="categoryChild" :multiple="multiple" v-model="model">
    </CategoryPane>
  </Category>
</template>

<script setup lang="ts">
import { useAllSearchSettingList, useSearchSettingType } from '@12333/hooks';
import { useDictionaryDataSelect, useGetDictionaryCategorySelect } from '@12333/hooks';
import Category from './Category.vue';
import CategoryPane from './CategoryPane.vue';
import { reactive, computed, watch } from 'vue';
import { SearchType } from '@12333/constants';
import { CategoryCode } from '@12333/constants';

defineOptions({
  name: 'PositionSelectView',
@@ -28,27 +28,44 @@
const model = defineModel<string[]>();

const state = reactive({
  provinceIndex: 0,
  industryIndex: 0,
});

const { allSearchSettingList: positionList } = useAllSearchSettingList({
  searchType: SearchType.Position,
const { dictionaryDataList: industryList } = useDictionaryDataSelect({
  categoryCode: CategoryCode.IndustryCategory,
});
const { searchSettingTypeList: industryList } = useSearchSettingType({
  searchType: SearchType.IndustryCategory,

const _industryList = computed(() =>
  industryList.value.map((x) => ({
    ...x,
    name: x.label,
    id: x.value,
  }))
);

const { dictionaryDataList: positionList } = useDictionaryDataSelect({
  categoryCode: CategoryCode.Position,
});

const _positionList = computed(() =>
  positionList.value.map((x) => ({
    ...x,
    name: x.label,
    id: x.value,
  }))
);

const categoryChild = computed(() => {
  if (!industryList.value.length) {
  if (!_industryList.value.length) {
    return [];
  }
  return positionList.value?.filter(
    (x) => x.parentName === industryList.value[state.provinceIndex].name
  return _positionList.value?.filter(
    (x) => x.data.field1 === _industryList.value[state.industryIndex]?.code
  );
});

const change = (index: number) => {
  state.provinceIndex = index;
  state.industryIndex = index;
};
</script>


 packages/components/src/Form/ProRadio.vue

@@ -31,8 +31,8 @@
const props = withDefaults(defineProps<Props>(), {
  allBtnLabel: '不限',
  allBtnValue: '',
  enumLabelKey: 'name',
  enumValueKey: 'id',
  enumLabelKey: 'label',
  enumValueKey: 'value',
});

const model = defineModel<string | number>();

 packages/components/tsconfig.json

@@ -10,6 +10,7 @@
    "types": [
      "node",
      "@12333/services/api/typings.d.ts",
      "@12333/services/apiV2/typings.d.ts",
      "@12333/services/types.d.ts",
      "@12333/services/globalType.d.ts",
      "../../types/api.d.ts"

 packages/constants/apiEnum.ts

@@ -41,6 +41,14 @@
  Desc = 1,
}

/** 实名通道 */
export enum EnumRealAccess {
  /**上上签 */
  BestSign = 10,
  /**支付宝信任签 */
  AlipaySign = 20,
}

/** 资源控制器 */
export enum EnumResourceController {
  /**数据字典 */
@@ -87,6 +95,12 @@
  All = 999,
}

/** 短信通道 */
export enum EnumSmsAccess {
  /**阿里云短信 */
  AliyunSms = 10,
}

/** 用户信息状态 */
export enum EnumUserInfoStatus {
  /**正常 */

 packages/constants/dic.ts

@@ -1,100 +1,14 @@
export enum SearchType {
export enum CategoryCode {
  /**身份 */
  Identity = 210,
  Identity = '10',
  /**学历 */
  Education = 220,
  Education = '20',
  /**岗位 */
  Position = 230,
  Position = '30',
  /**证书类型 */
  CertificateType = 240,
  CertificateType = '40',
  /**福利 */
  Welfare = 250,
  Welfare = '50',
  /**行业类型 */
  IndustryCategory = 260,
  IndustryCategory = '60',
}

export const SearchTypeText = {
  [SearchType.Identity]: '身份',
  [SearchType.Education]: '学历',
  [SearchType.Position]: '岗位',
  [SearchType.CertificateType]: '证书类型',
  [SearchType.Welfare]: '福利',
  [SearchType.IndustryCategory]: '行业类型',
};

export enum BelongType {
  Park = 10,
  Human = 20,
  Product = 30,
  Information = 40,
  FlexiblePlatform = 60,
  LaborRecruitment = 70,
  DemandDevelopment = 80,
  TrainingInstitutions = 90,
}

export enum IndustryCategoryType {
  /**
   * 行业服务
   */
  IndustryServices = 0,
  /**
   * 行业配套
   */
  IndustryMatching,

  /**
   * 甲方需求
   */
  FirstPartyDemand,
  /**
   * 行业资讯
   */
  IndustryInformation,
}

export const IndustryCategoryTypeText = {
  [IndustryCategoryType.IndustryServices]: '行业服务',
  [IndustryCategoryType.IndustryMatching]: '行业配套',
  [IndustryCategoryType.FirstPartyDemand]: '甲方需求',
  [IndustryCategoryType.IndustryInformation]: '行业资讯',
};

export enum TagType {
  /**
   * 产品标签
   */
  ProductTag = 0,
  /**
   * 资讯标签
   */
  InformationTag,
  /**
   * 定义标签
   */
  CustomTag,
  /**
   * 快捷评论标签
   */
  QuickEvaluateTag,
}

export enum UpLevel {
  /**
   * 一级
   */
  One = 1,
  /**
   * 二级
   */
  Two,
  /**
   * 三级
   */
  Three,
}
export const UpLevelText = {
  [UpLevel.One]: '一级',
  [UpLevel.Two]: '二级',
  [UpLevel.Three]: '三级',
};

 packages/hooks/dic.ts

@@ -1,134 +1,109 @@
import * as searchSettingServices from '@12333/services/api/SearchSetting';
import { useQuery, useQueryClient } from '@tanstack/vue-query';
import { SearchType } from '@12333/constants';
import { MaybeRef, computed } from 'vue';
import * as dictionaryServices from '@12333/services/apiV2/dictionary';
import { MaybeRef, unref } from 'vue';
import { CategoryCode } from '@12333/constants';

type UseSearchSettingTypeOptions = {
  searchType: number;
  belongType?: number;
  onSuccess?: (data: API.GetTypeSearchSettingList[]) => any;
  enabled?: MaybeRef<boolean>;
};

export function useSearchSettingType({
  searchType,
  belongType = null,
  onSuccess,
  enabled = true,
}: UseSearchSettingTypeOptions) {
  const { data, refetch } = useQuery({
    queryKey: ['searchSettingServices/getTypeSearchSettingList', { searchType, belongType }],
export function useGetDictionaryCategorySelect() {
  const { data: dictionaryCategoryList, refetch } = useQuery({
    queryKey: ['dictionaryServices/getDictionaryCategorySelect'],
    queryFn: async () => {
      return await searchSettingServices.getTypeSearchSettingList(
        {
          searchType: searchType,
          belongType: belongType,
        },
        { showLoading: false }
      );
      let res = await dictionaryServices.getDictionaryCategorySelect({}, { showLoading: false });
      return res.map((x) => ({
        ...x,
        fieldNamesMap: x.data.fieldNames ? JSON.parse(x.data.fieldNames) : {},
      }));
    },
    placeholderData: () => [] as API.GetTypeSearchSettingList[],
    onSuccess(data) {
      onSuccess?.(data);
    },
    enabled,
    placeholderData: () =>
      [] as API.SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOption[],
  });

  const queryClient = useQueryClient();

  async function ensureSearchSettingType() {
    return await queryClient.ensureQueryData({
      queryKey: [
        'searchSettingServices/getTypeSearchSettingList',
        { searchType: searchType, belongType: belongType },
      ],
  function ensureQueryData() {
    return queryClient.ensureQueryData<
      API.SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOption[]
    >({
      queryKey: ['dictionaryServices/getDictionaryCategorySelect'],
    });
  }

  function getSearchSettingTypeNameById(id: string) {
    return data.value.find((x) => x.id === id)?.name ?? '';
  function getDictionaryCategoryById(id: string) {
    return dictionaryCategoryList.value.find((x) => x.value === id);
  }

  function getDictionaryCategoryByCode(code: string) {
    return dictionaryCategoryList.value.find((x) => x.code === code);
  }

  function getDictionaryCategoryNameByCode(code: string) {
    return getDictionaryCategoryByCode(code)?.label ?? '';
  }

  return {
    searchSettingTypeList: data,
    ensureSearchSettingType,
    refetchSearchSettingType: refetch,
    getSearchSettingTypeNameById,
    dictionaryCategoryList,
    ensureQueryData,
    getDictionaryCategoryById,
    getDictionaryCategoryNameByCode,
    getDictionaryCategoryByCode,
  };
}

type UseAllSearchSettingList = API.GetSearchSettingListInput & {
  enabled?: MaybeRef<boolean>;
type UseDictionaryDataSelectOptions = {
  categoryId?: MaybeRef<string>;
  categoryCode?: MaybeRef<CategoryCode>;
};

export function useAllSearchSettingList(options: UseAllSearchSettingList) {
  const { enabled = true, ...params } = options;

  const { data: allSearchSettingList } = useQuery({
    queryKey: ['searchSettingServices/getAllSearchSettingList', params],
export function useDictionaryDataSelect({
  categoryId,
  categoryCode,
}: UseDictionaryDataSelectOptions) {
  const { data: dictionaryDataList, refetch } = useQuery({
    queryKey: ['dictionaryServices/getDictionaryDataSelect', categoryId, categoryCode],
    queryFn: async () => {
      return await searchSettingServices.getAllSearchSettingList(params, { showLoading: false });
      let res = await dictionaryServices.getDictionaryDataSelect(
        {
          categoryId: unref(categoryId),
          categoryCode: unref(categoryCode),
        },
        { showLoading: false }
      );
      return res.map((x) => ({
        ...x,
        code: x.data?.code ?? '',
      }));
    },
    initialData: () => [] as API.GetSearchSettingList[],
    enabled,
    placeholderData: () =>
      [] as API.SelectQueryResultOptionGuidGetDictionaryDataSelectQueryResultOption[],
  });

  return {
    allSearchSettingList,
  };
}

type UseWorkOfTypeOptions = {
  enabled?: MaybeRef<boolean>;
};

export function useWorkOfType(options: UseWorkOfTypeOptions = {}) {
  const { enabled = true } = options;

  const { allSearchSettingList: industryCategoryList } = useAllSearchSettingList({
    searchType: SearchType.IndustryCategory,
    enabled,
    status: true,
  });

  const { allSearchSettingList: flattenWorkOfTypeList } = useAllSearchSettingList({
    searchType: SearchType.Work,
    enabled,
    status: true,
  });

  const workOfTypeList = computed<API.GetSearchSettingList[]>(() => {
    if (industryCategoryList.value?.length > 0) {
      let list = [];
      industryCategoryList.value.forEach((x) => {
        list.push({
          ...x,
          children: flattenWorkOfTypeList.value.filter((w) => w.parentId === x.id),
        });
      });
      return list;
    }
    return [];
  });

  const workOfTypeRecommendList = computed<API.GetSearchSettingList[]>(() => {
    if (flattenWorkOfTypeList.value?.length > 0) {
      return flattenWorkOfTypeList.value.filter((w) => w.isRecommend);
    }
    return [];
  });

  function getWorkOfTypeNameById(id: string) {
    return flattenWorkOfTypeList.value.find((x) => x.id === id)?.name ?? '';
  function getDictionaryDataNameById(id: string) {
    return dictionaryDataList.value?.find((x) => x.value === id)?.label;
  }

  const MaxSelectWorkOfTypeLimit = 6;
  function getDictionaryDataByCode(code: string) {
    return dictionaryDataList.value?.find((x) => x.code === code);
  }

  function getDictionaryDataNameByCode(code: string) {
    return getDictionaryDataByCode(code)?.label ?? '';
  }

  const queryClient = useQueryClient();

  function ensureQueryData() {
    return queryClient.ensureQueryData<
      API.SelectQueryResultOptionGuidGetDictionaryDataSelectQueryResultOption[]
    >({
      queryKey: ['dictionaryServices/getDictionaryDataSelect'],
    });
  }

  return {
    workOfTypeList: workOfTypeList,
    flattenWorkOfTypeList,
    workOfTypeRecommendList,
    getWorkOfTypeNameById,
    MaxSelectWorkOfTypeLimit,
    dictionaryDataList,
    ensureQueryData,
    refetch,
    getDictionaryDataNameById,
    getDictionaryDataNameByCode,
    getDictionaryDataByCode,
  };
}

 packages/hooks/tsconfig.json

@@ -10,6 +10,7 @@
    "types": [
      "node",
      "@12333/services/api/typings.d.ts",
      "@12333/services/apiV2/typings.d.ts",
      "@12333/services/types.d.ts",
      "@12333/services/globalType.d.ts",
      "../../types/api.d.ts"

 packages/services/apiV2/auth.ts

@@ -19,6 +19,21 @@
  });
}

/** 获取当前登录用户菜单详情 GET /api/user/auth/getCurrentLogierMenu */
export async function getCurrentLogierMenu(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCurrentLogierMenuParams,
  options?: API.RequestConfig
) {
  return request<API.GetMenuQueryResult>('/api/user/auth/getCurrentLogierMenu', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取当前登录用户菜单 GET /api/user/auth/getCurrentLogierMenus */
export async function getCurrentLogierMenus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)

 packages/services/apiV2/dictionary.ts

@@ -2,7 +2,7 @@
// @ts-ignore
import { request } from '@/utils/request';

/** 删除字典类别 DELETE /api/main/dictionary/deleteDictionaryCategory */
/** 删除数据字典类别 DELETE /api/main/dictionary/deleteDictionaryCategory */
export async function deleteDictionaryCategory(
  body: API.DeleteDictionaryCategoryCommand,
  options?: API.RequestConfig
@@ -17,7 +17,7 @@
  });
}

/** 查询字典类别分页列表数据 POST /api/main/dictionary/getDictionaryCategories */
/** 获取数据字典类别分页列表数据 POST /api/main/dictionary/getDictionaryCategories */
export async function getDictionaryCategories(
  body: API.GetDictionaryCategoriesQuery,
  options?: API.RequestConfig
@@ -35,7 +35,27 @@
  );
}

/** 获取字典数据分页列表 POST /api/main/dictionary/getDictionaryDatas */
/** 查询数据字典类别选择器数据 GET /api/main/dictionary/getDictionaryCategorySelect */
export async function getDictionaryCategorySelect(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetDictionaryCategorySelectParams,
  options?: API.RequestConfig
) {
  return request<API.SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOption[]>(
    '/api/main/dictionary/getDictionaryCategorySelect',
    {
      method: 'GET',
      params: {
        ...params,
        request: undefined,
        ...params['request'],
      },
      ...(options || {}),
    }
  );
}

/** 获取数据字典分页列表数据 POST /api/main/dictionary/getDictionaryDatas */
export async function getDictionaryDatas(
  body: API.GetDictionaryDatasQuery,
  options?: API.RequestConfig
@@ -53,7 +73,25 @@
  );
}

/** 保存字典类别 POST /api/main/dictionary/saveDictionaryCategory */
/** 查询数据字典选择器 GET /api/main/dictionary/getDictionaryDataSelect */
export async function getDictionaryDataSelect(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetDictionaryDataSelectParams,
  options?: API.RequestConfig
) {
  return request<API.SelectQueryResultOptionGuidGetDictionaryDataSelectQueryResultOption[]>(
    '/api/main/dictionary/getDictionaryDataSelect',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 保存数据字典类别 POST /api/main/dictionary/saveDictionaryCategory */
export async function saveDictionaryCategory(
  body: API.SaveDictionaryCategoryCommand,
  options?: API.RequestConfig
@@ -68,7 +106,7 @@
  });
}

/** 保存字典数据 POST /api/main/dictionary/saveDictionaryData */
/** 保存数据字典 POST /api/main/dictionary/saveDictionaryData */
export async function saveDictionaryData(
  body: API.SaveDictionaryDataCommand,
  options?: API.RequestConfig
@@ -83,7 +121,7 @@
  });
}

/** 设置字典数据是否禁用 PUT /api/main/dictionary/setDictionaryDataIsDisabled */
/** 设置数据字典是否禁用 PUT /api/main/dictionary/setDictionaryDataIsDisabled */
export async function setDictionaryDataIsDisabled(
  body: API.SetDictionaryDataIsDisabledCommand,
  options?: API.RequestConfig

 packages/services/apiV2/enterprise.ts

@@ -16,3 +16,45 @@
    }
  );
}

/** 保存企业 POST /api/user/enterprise/saveEnterprise */
export async function saveEnterprise(body: API.SaveEnterpriseCommand, options?: API.RequestConfig) {
  return request<string>('/api/user/enterprise/saveEnterprise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json-patch+json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置企业电子签配置 PUT /api/user/enterprise/setEnterpriseElectronSignSetting */
export async function setEnterpriseElectronSignSetting(
  body: API.SetEnterpriseElectronSignSettingCommand,
  options?: API.RequestConfig
) {
  return request<string>('/api/user/enterprise/setEnterpriseElectronSignSetting', {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json-patch+json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置企业短信配置 PUT /api/user/enterprise/setEnterpriseSmsSetting */
export async function setEnterpriseSmsSetting(
  body: API.SetEnterpriseSmsSettingCommand,
  options?: API.RequestConfig
) {
  return request<string>('/api/user/enterprise/setEnterpriseSmsSetting', {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json-patch+json',
    },
    data: body,
    ...(options || {}),
  });
}

 packages/services/apiV2/index.ts

@@ -2,19 +2,19 @@
/* eslint-disable */
// API 更新时间：
// API 唯一标识：
import * as dictionary from './dictionary';
import * as auth from './auth';
import * as enterprise from './enterprise';
import * as menu from './menu';
import * as dictionary from './dictionary';
import * as resource from './resource';
import * as role from './role';
import * as userInfo from './userInfo';
import * as enterprise from './enterprise';
export default {
  dictionary,
  auth,
  enterprise,
  menu,
  dictionary,
  resource,
  role,
  userInfo,
  enterprise,
};

 packages/services/apiV2/typings.d.ts

@@ -8,9 +8,28 @@
    request?: GetAliyunOSSAcsQuery;
  }

  interface APIgetCurrentLogierMenuParams {
    /** Id */
    id?: string;
  }

  interface APIgetCurrentLogierMenusParams {
    /** 获取当前登录用户菜单 */
    request?: GetCurrentLogierMenusQuery;
  }

  interface APIgetDictionaryCategorySelectParams {
    /** 查询数据字典类别选择器数据 */
    request?: GetDictionaryCategorySelectQuery;
  }

  interface APIgetDictionaryDataSelectParams {
    /** 类别Id（Id/编号二选一） */
    categoryId?: string;
    /** 类别编号（Id/编号二选一） */
    categoryCode?: string;
    /** 上级Id */
    parentId?: string;
  }

  interface APIgetMenuParams {
@@ -72,6 +91,77 @@
    ids: string[];
  }

  interface DictionaryCategory {
    id?: string;
    createdTime?: string;
    updatedTime?: string;
    /** 排序 */
    sort?: number;
    /** 跟踪Id */
    traceId?: string;
    /** 创建操作人 */
    createdUserInfoId?: string;
    /** 最后更新操作人 */
    updatedUserInfoId?: string;
    /** 是否删除 */
    isDeleted?: boolean;
    /** 编号 */
    code: string;
    /** 名称 */
    name: string;
    /** 字段名（逗号隔开） */
    fieldNames?: string;
    /** 备注 */
    remark?: string;
  }

  interface DictionaryData {
    id?: string;
    createdTime?: string;
    updatedTime?: string;
    /** 排序 */
    sort?: number;
    /** 跟踪Id */
    traceId?: string;
    /** 创建操作人 */
    createdUserInfoId?: string;
    /** 最后更新操作人 */
    updatedUserInfoId?: string;
    /** 是否删除 */
    isDeleted?: boolean;
    /** 类别Id */
    categoryId?: string;
    category?: DictionaryCategory;
    /** 上级Id */
    parentId?: string;
    parent?: DictionaryData;
    /** 下级 */
    children?: DictionaryData[];
    /** 字典路径 */
    path?: string;
    /** 编号 */
    code?: string;
    /** 显示内容 */
    content: string;
    /** 字段1 */
    field1?: string;
    /** 字段2 */
    field2?: string;
    /** 字段3 */
    field3?: string;
    /** 字段4 */
    field4?: string;
    /** 字段5 */
    field5?: string;
    /** 是否禁用 */
    isDisabled?: boolean;
  }

  interface DictionaryDataQueryResult {
    /** 内容 */
    content?: string;
  }

  enum EnumClientType {
    /**电脑网页 */
    PcWeb = 10,
@@ -106,6 +196,13 @@
    Asc = 0,
    /**降序 */
    Desc = 1,
  }

  enum EnumRealAccess {
    /**上上签 */
    BestSign = 10,
    /**支付宝信任签 */
    AlipaySign = 20,
  }

  enum EnumResourceController {
@@ -149,6 +246,11 @@
    CurrentEnterprise = 30,
    /**查询所有 */
    All = 999,
  }

  enum EnumSmsAccess {
    /**阿里云短信 */
    AliyunSms = 10,
  }

  enum EnumUserInfoStatus {
@@ -354,6 +456,44 @@
    timestamp?: number;
  }

  interface FriendlyResultListSelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOption {
    /** 跟踪Id */
    traceId?: string;
    /** 状态码 */
    code?: number;
    /** 错误码 */
    errorCode?: string;
    /** 数据 */
    data?: SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOption[];
    /** 执行成功 */
    success?: boolean;
    /** 错误信息 */
    msg?: any;
    /** 附加数据 */
    extras?: any;
    /** 时间戳 */
    timestamp?: number;
  }

  interface FriendlyResultListSelectQueryResultOptionGuidGetDictionaryDataSelectQueryResultOption {
    /** 跟踪Id */
    traceId?: string;
    /** 状态码 */
    code?: number;
    /** 错误码 */
    errorCode?: string;
    /** 数据 */
    data?: SelectQueryResultOptionGuidGetDictionaryDataSelectQueryResultOption[];
    /** 执行成功 */
    success?: boolean;
    /** 错误信息 */
    msg?: any;
    /** 附加数据 */
    extras?: any;
    /** 时间戳 */
    timestamp?: number;
  }

  interface FriendlyResultPagedListQueryResultGetDictionaryCategoriesQueryResultItem {
    /** 跟踪Id */
    traceId?: string;
@@ -493,10 +633,14 @@
    sort?: number;
  }

  type GetDictionaryCategorySelectQuery = Record<string, any>;

  interface GetDictionaryDatasQuery {
    pageModel?: PagedListQueryPageModel;
    /** 类别Id */
    /** 类别Id（Id/编号二选一） */
    categoryId?: string;
    /** 类别编号（Id/编号二选一） */
    categoryCode?: string;
    /** 关键字 */
    keywords?: string;
  }
@@ -506,6 +650,11 @@
    id?: string;
    /** 类别Id */
    categoryId?: string;
    /** 类别编号 */
    categoryCode?: string;
    /** 类别名称 */
    categoryName?: string;
    category?: GetDictionaryDatasQueryResultItemCategory;
    /** 上级Id */
    parentId?: string;
    /** 编号 */
@@ -528,6 +677,13 @@
    isDisabled?: boolean;
  }

  interface GetDictionaryDatasQueryResultItemCategory {
    /** 类别编号 */
    code?: string;
    /** 名称 */
    name?: string;
  }

  interface GetEnterprisesQuery {
    pageModel?: PagedListQueryPageModel;
    /** 关键字 */
@@ -539,16 +695,25 @@
  interface GetEnterprisesQueryResultItem {
    /** Id */
    id?: string;
    /** 企业全称 */
    enterpriseName?: string;
    /** 法人姓名 */
    legalPerson?: string;
    /** 统一社会信用代码 */
    societyCreditCode?: string;
    /** 联系人 */
    contacts?: string;
    /** 联系电话 */
    contactNumber?: string;
    /** 所在省份Id */
    provinceId?: string;
    province?: DictionaryDataQueryResult;
    /** 所在城市Id */
    cityId?: string;
    city?: DictionaryDataQueryResult;
    /** 所属行业Id */
    industryTypeId?: string;
    industryType?: DictionaryDataQueryResult;
    /** 是否已校验银行账户 */
    isCheckedBankCard?: boolean;
    realAccess?: EnumRealAccess;
    smsAccess?: EnumSmsAccess;
    /** 是否已配置 */
    isConfigured?: boolean;
  }

  interface GetMenuQueryResult {
@@ -877,6 +1042,7 @@
  }

  interface SaveDictionaryCategoryCommand {
    /** Id */
    id?: string;
    /** 编号 */
    code: string;
@@ -889,6 +1055,7 @@
  }

  interface SaveDictionaryDataCommand {
    /** Id */
    id?: string;
    /** 类别Id */
    categoryId?: string;
@@ -912,6 +1079,44 @@
    sort?: number;
    /** 是否禁用 */
    isDisabled?: boolean;
  }

  interface SaveEnterpriseCommand {
    /** Id */
    id?: string;
    enterpriseAuth: SaveEnterpriseCommandAuth;
    /** 所在省份Id */
    provinceId?: string;
    province?: DictionaryData;
    /** 所在城市Id */
    cityId?: string;
    city?: DictionaryData;
    /** 所属行业Id */
    industryTypeId?: string;
    industryType?: DictionaryData;
    /** 主营业务 */
    mainBusiness?: string;
    /** 联系人 */
    contacts?: string;
    /** 联系电话 */
    contactPhoneNumber?: string;
    /** 联系邮箱 */
    contactEmail?: string;
    /** 账号 */
    userName?: string;
    /** 密码 */
    password?: string;
  }

  interface SaveEnterpriseCommandAuth {
    /** 企业全称 */
    enterpriseName: string;
    /** 统一社会信用代码 */
    societyCreditCode: string;
    /** 法人姓名 */
    legalPerson?: string;
    /** 法人身份证号 */
    legalIdentity?: string;
  }

  interface SaveMenuButtonCommand {
@@ -1055,11 +1260,48 @@
    resources?: GetRoleQueryResultResource[];
  }

  interface SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOption {
    /** 值 */
    value?: string;
    /** 标签 */
    label?: string;
    /** 数据 */
    data?: any;
  }

  interface SelectQueryResultOptionGuidGetDictionaryDataSelectQueryResultOption {
    /** 值 */
    value?: string;
    /** 标签 */
    label?: string;
    /** 数据 */
    data?: any;
  }

  interface SetDictionaryDataIsDisabledCommand {
    /** Id */
    ids?: string[];
    /** 是否禁用 */
    /** 是否已禁用 */
    isDisabled?: boolean;
  }

  interface SetEnterpriseElectronSignSettingCommand {
    /** Id */
    id?: string;
    realAccess?: EnumRealAccess;
    /** 实名费用 */
    realVerifyCost?: number;
    /** 签约费用 */
    signCost?: number;
    /** 一口价 */
    mergeSignCost?: number;
  }

  interface SetEnterpriseSmsSettingCommand {
    /** Id */
    id?: string;
    smsAccess?: EnumSmsAccess;
    /** 短信费用 */
    smsCost?: number;
  }

  interface SetMenuSwitchCommand {
@@ -1073,9 +1315,8 @@
  }

  interface SetRoleIsDisabledCommand {
    /** Id */
    ids: string[];
    /** 是否禁用 */
    ids?: string[];
    /** 是否已禁用 */
    isDisabled?: boolean;
  }


 types/api.d.ts

@@ -20,4 +20,17 @@
    /**接口返回的原始头像 */
    originalAvatarUrl?: string
  }

  interface SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOptionMap{
    field1?:string
  }

  interface SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOption{
    fieldNamesMap?: SelectQueryResultOptionGuidGetDictionaryCategorySelectQueryOptionMap;
    code?:string
  }

  interface SelectQueryResultOptionGuidGetDictionaryDataSelectQueryResultOption{
    code?:string
  }
}