Merge branch 'master' into dev-v1.1

wupengfei

2025-09-12 7cf04da7eaba7cad9c3b5e5f674d2e038ebcd305

 packages/hooks/area.ts

@@ -1,119 +1,125 @@
import { flattenAreaTree, formatAreaListToTree } from '@12333/utils';
import * as flexWorkerServices from '@12333/services/api/FlexWorker';
import { useQuery, useQueryClient } from '@tanstack/vue-query';
import { computed, onMounted, onUnmounted, ref } from 'vue';
import { AreaType } from '@12333/constants';
import { computed, MaybeRef, onMounted, onUnmounted, ref, unref } from 'vue';
import { AreaType, CategoryCode } from '@12333/constants';
import Taro, { EventChannel } from '@tarojs/taro';
import { useDictionaryDataSelect } from './dic';
import axios from 'axios';
import * as dictionaryServices from '@12333/services/apiV2/dictionary';

export function useArea() {
  // const completeAreaList = ref<API.AreaInfo[]>([]);
  // const completeAreaTree = ref<API.AreaTreeNode[]>([]);
  // const provinceList = ref<API.AreaInfo[]>([]);
  // const areaItemMap = ref<Record<API.AreaInfo['areaCode'], API.AreaInfo>>({});

  const queryClient = useQueryClient();

  const { data: areaStore } = useQuery({
    queryKey: ['flexWorkerServices/getAreaList'],
    queryFn: async () => {
      return await flexWorkerServices.getAreaList({}, { showLoading: false });
    },
    placeholderData: () => [] as API.AreaDto[],
    staleTime: Infinity,
    select(data) {
      const areaItemMap: Record<API.AreaDto['areaCode'], API.AreaDto> = {};
      data.forEach((item) => {
        areaItemMap[item.areaCode] = item;
      });
      const completeAreaList = flattenAreaTree([...data]);
      return {
        completeAreaList: completeAreaList,
        completeAreaTree: [...data],
        // cityAreaTree: formatAreaListToTree(completeAreaList, 0, AreaType.City),
        provinceList: [...data],
        areaItemMap: areaItemMap,
      };
    },
  });
  const { areaList } = useAllAreaList();

  // onMounted(async () => {
  //   let data: API.AreaInfo[] = await queryClient.ensureQueryData({
  //     queryKey: ['areaServices/getRegionalManagementList'],
  //   });
  //   completeAreaList.value = flattenAreaTree([...data]);
  //   completeAreaTree.value = [...data];
  //   provinceList.value = [...data];
  //   setAreaMap([...data]);
  // });
  // const areaList = computed(() => dictionaryDataList.value.map(convertDictionaryToAreaTreeNode));

  // function setAreaMap(areaList: API.AreaInfo[]) {
  //   areaList.forEach((item) => {
  //     areaItemMap[item.areaCode] = item;
  //   });
  // }

  function getAreaFromCompleteAreaList(areaCode: number) {
    return areaStore.value.completeAreaList.find((x) => x.areaCode === areaCode);
  function getAreaFromCompleteAreaList(areaCode: string) {
    return areaList.value.find((x) => x.areaCode === areaCode);
  }

  function getAreaByAreaCode(areaCode: number) {
    return areaStore.value.areaItemMap[areaCode];
  function getAreaByAreaCode(areaCode: string) {
    return areaList.value.find((x) => x.areaCode === areaCode);
  }

  return {
    completeAreaList: computed(() => areaStore.value.completeAreaList),
    completeAreaTree: computed(() => areaStore.value.completeAreaTree),
    cityAreaTree: computed(() =>
      areaStore.value.completeAreaTree.map((x) => ({
        ...x,
        children: x.children.map((y) => ({
          ...y,
          children: undefined,
        })),
      }))
    ),
    provinceList: computed(() => areaStore.value.provinceList),
    areaItemMap: computed(() => areaStore.value.areaItemMap),
    completeAreaList: areaList,
    areaList,
    // completeAreaTree: areaTree,
    // provinceList: computed(() => areaList.value.filter((x) => x.layer === AreaType.Province)),
    getAreaFromCompleteAreaList,
    getAreaByAreaCode,
  };
}

type UseAreaTreeOptions = {
  maxLayer?: MaybeRef<AreaType>;
};

export function useAreaTree(options = {} as UseAreaTreeOptions) {
  const { maxLayer = AreaType.Area } = options;

  // const { areaList } = useAllAreaList();

  const { data: areaTree } = useQuery({
    queryKey: ['dictionaryServices/getAreaSelect', maxLayer],
    queryFn: () => {
      return dictionaryServices.getAreaSelect(
        {
          maxDeep: unref(maxLayer),
        },
        { showLoading: false }
      );
    },
    placeholderData: () => [] as API.GetAreaSelectQueryResultOption[],
    staleTime: Infinity,
  });

  // const areaTree = computed(() => formatAreaListToTree(areaList.value, null, unref(maxLayer)));
  console.log('areaTree: ', areaTree);

  return { areaTree: areaTree };
}

function convertDictionaryToAreaTreeNode(
  item: API.SelectOptionStringGetDictionaryDataSelectQueryResultOption
) {
  return {
    areaCode: item.data?.code,
    parentCode: item.data?.parentCode,
    areaName: item.label,
    layer: Number(item.data?.field4),
    quickQuery: item.data?.field2,
    sort: item.data?.sort,
    id: item.data?.id,
  } as API.AreaTreeNode;
}

export function useAllAreaList() {
  const { completeAreaTree, provinceList, completeAreaList, cityAreaTree } = useArea();
  const { data: areaList } = useQuery({
    queryKey: ['area.txt'],
    queryFn() {
      return axios
        .get<API.AreaTreeNode[]>(
          'https://parkmanagement.oss-cn-hangzhou.aliyuncs.com/12333/area.txt'
        )
        .then((res) => res.data);
    },

    placeholderData: () => [] as API.AreaTreeNode[],
    staleTime: Infinity,
  });

  const findAreaCodeFromName = (areaName: string) => {
    const areaItem = completeAreaList.value.find((x) => x.areaName === areaName);
    return areaItem?.areaCode ?? 0;
    const areaItem = areaList.value.find((x) => x.areaName === areaName);
    return areaItem?.areaCode ?? '';
  };

  const findAreaNameFromCode = (areaCode: number) => {
    const areaItem = completeAreaList.value.find((x) => x.areaCode === areaCode);
  const findAreaNameFromCode = (areaCode: string) => {
    const areaItem = areaList.value.find((x) => x.areaCode === areaCode);
    return areaItem?.areaName ?? '';
  };

  const findAreaItemFromCode = (areaCode: number) => {
    const areaItem = completeAreaList.value.find((x) => x.areaCode === areaCode);
  const findAreaItemFromCode = (areaCode: string) => {
    const areaItem = areaList.value.find((x) => x.areaCode === areaCode);
    return areaItem;
  };

  return {
    areaList,
    findAreaCodeFromName,
    findAreaNameFromCode,
    findAreaItemFromCode,
    areaTreeList: completeAreaTree,
    provinceList,
    cityAreaTree,
  };
}

export function useProvinceList() {
  const { provinceList } = useArea();
// export function useProvinceList() {
//   const { provinceList } = useArea();

  return {
    provinceList,
  };
}
//   return {
//     provinceList,
//   };
// }

export const globalEventEmitter = new Taro.Events();