From e3ae5da789eb35217a4a377cab0ff3241ceaf72a Mon Sep 17 00:00:00 2001
From: wupengfei <834520024@qq.com>
Date: 星期一, 11 八月 2025 13:42:07 +0800
Subject: [PATCH] feat: 接口对接

---
 packages/hooks/area.ts |  108 ++++++++++++++++++++----------------------------------
 1 files changed, 40 insertions(+), 68 deletions(-)

diff --git a/packages/hooks/area.ts b/packages/hooks/area.ts
index 46668cf..f8bd597 100644
--- a/packages/hooks/area.ts
+++ b/packages/hooks/area.ts
@@ -1,109 +1,81 @@
 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 { AreaType, CategoryCode } from '@12333/constants';
 import Taro, { EventChannel } from '@tarojs/taro';
+import { useDictionaryDataSelect } from './dic';
 
 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[],
+  const { dictionaryDataList } = useDictionaryDataSelect({
+    categoryCode: CategoryCode.Area,
     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,
-      };
-    },
+    all: true,
+    maxDeep: AreaType.City,
   });
 
-  // 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));
+  console.log('areaList: ', areaList);
 
-  // function setAreaMap(areaList: API.AreaInfo[]) {
-  //   areaList.forEach((item) => {
-  //     areaItemMap[item.areaCode] = item;
-  //   });
-  // }
+  const areaTree = computed(() => formatAreaListToTree(areaList.value));
 
-  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,
   };
 }
 
+function convertDictionaryToAreaTreeNode(
+  item: API.SelectOptionStringGetDictionaryDataSelectQueryResultOption
+) {
+  return {
+    children: [],
+    areaCode: item.data?.code,
+    parentCode: item.data?.field1,
+    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 { areaList } = useArea();
 
   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,
   };
 }
 

--
Gitblit v1.9.1