feat: 接口对接

wupengfei

2025-03-11 286f1b727856d6b32a8d237f353ae008f3076deb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
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 Taro, { EventChannel } from '@tarojs/taro';
 
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,
      };
    },
  });
 
  // onMounted(async () => {
  //   let data: API.AreaInfo[] = await queryClient.ensureQueryData({
  //     queryKey: ['areaServices/getRegionalManagementList'],
  //   });
  //   completeAreaList.value = flattenAreaTree([...data]);
  //   completeAreaTree.value = [...data];
  //   provinceList.value = [...data];
  //   setAreaMap([...data]);
  // });
 
  // 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 getAreaByAreaCode(areaCode: number) {
    return areaStore.value.areaItemMap[areaCode];
  }
 
  return {
    completeAreaList: computed(() => areaStore.value.completeAreaList),
    completeAreaTree: computed(() => areaStore.value.completeAreaTree),
    // cityAreaTree: computed(() => areaStore.value.cityAreaTree),
    provinceList: computed(() => areaStore.value.provinceList),
    areaItemMap: computed(() => areaStore.value.areaItemMap),
    getAreaFromCompleteAreaList,
    getAreaByAreaCode,
  };
}
 
export function useAllAreaList() {
  const { completeAreaTree, provinceList, completeAreaList } = useArea();
 
  const findAreaCodeFromName = (areaName: string) => {
    const areaItem = completeAreaList.value.find((x) => x.areaName === areaName);
    return areaItem?.areaCode ?? 0;
  };
 
  const findAreaNameFromCode = (areaCode: number) => {
    const areaItem = completeAreaList.value.find((x) => x.areaCode === areaCode);
    return areaItem?.areaName ?? '';
  };
 
  const findAreaItemFromCode = (areaCode: number) => {
    const areaItem = completeAreaList.value.find((x) => x.areaCode === areaCode);
    return areaItem;
  };
 
  return {
    findAreaCodeFromName,
    findAreaNameFromCode,
    findAreaItemFromCode,
    areaTreeList: completeAreaTree,
    provinceList,
  };
}
 
export function useProvinceList() {
  const { provinceList } = useArea();
 
  return {
    provinceList,
  };
}
 
export const globalEventEmitter = new Taro.Events();
 
export function useEvent(eventName: string, fn: TaroGeneral.EventCallback) {
  onMounted(() => {
    if (globalEventEmitter?.on) {
      globalEventEmitter.on(eventName, fn);
    }
  });
 
  onUnmounted(() => {
    if (globalEventEmitter?.off) {
      globalEventEmitter.off(eventName, fn);
    }
  });
}