From 9e5a47d90455c4770815d32899f660b53fc27110 Mon Sep 17 00:00:00 2001
From: wupengfei <834520024@qq.com>
Date: 星期四, 22 五月 2025 13:26:09 +0800
Subject: [PATCH] Merge branch 'dev-ui' of http://120.26.58.240:8888/r/LifePaymentFront into dev-ui

---
 packages/components/src/hooks/index.ts |  245 +++++++++++++++++++++++++++++++++++++++++++++---
 1 files changed, 228 insertions(+), 17 deletions(-)

diff --git a/packages/components/src/hooks/index.ts b/packages/components/src/hooks/index.ts
index 5071f6a..b8ce406 100644
--- a/packages/components/src/hooks/index.ts
+++ b/packages/components/src/hooks/index.ts
@@ -6,11 +6,18 @@
   QueryLifePayOrderListInput,
   LifeRechargeConstants,
   ElectricParValueResponse,
+  ElectricSupportAreaResponse,
+  QueryUserAccountAllListInput,
+  UserAccountListOutput,
+  AddUpdateUserAccountInput,
+  GasParValueResponse,
+  ChannelRateOutput,
 } from '@life-payment/core-vue';
-import { useQuery } from '@tanstack/vue-query';
+import { useQuery, useQueryClient } from '@tanstack/vue-query';
 import { computed, MaybeRef, reactive, unref } from 'vue';
 import { useInfiniteLoading } from './infiniteLoading';
 import { OrderInputType } from '../constants';
+import { convertOrderFrontStatus } from '../utils';
 
 export function useGetRate() {
   const { blLifeRecharge } = useLifeRechargeContext();
@@ -23,24 +30,60 @@
     placeholderData: () => [] as LifePayRateListOutput[],
   });
 
-  const lifePayPhoneRate = computed(
-    () =>
+  const hasChannel = computed(() => !!blLifeRecharge.accountModel.channlesNum);
+
+  const { data: channelRate } = useQuery({
+    queryKey: ['blLifeRecharge/getChannelRate', blLifeRecharge.accountModel.channlesNum],
+    queryFn: async () => {
+      return await blLifeRecharge.services.getChannelRate(
+        {
+          checkChannelId: blLifeRecharge.accountModel.channlesNum,
+        },
+        { showLoading: false }
+      );
+    },
+    placeholderData: () => ({} as ChannelRateOutput),
+    enabled: hasChannel,
+  });
+
+  const lifePayPhoneRate = computed(() => {
+    if (hasChannel.value && channelRate.value.channlesRate) {
+      return channelRate.value.channlesRate;
+    }
+    return (
       lifePayRateList.value.find(
         (x) => x.rateType === blLifeRecharge.constants.LifePayRateTypeEnum.榛樿璇濊垂鎶樻墸
-      )?.rate ?? 1
-  );
+      )?.rate ?? 0
+    );
+  });
 
-  const lifePayElectricRate = computed(
-    () =>
+  const lifePayElectricRate = computed(() => {
+    if (hasChannel.value && channelRate.value.channlesRate) {
+      return channelRate.value.channlesRate;
+    }
+    return (
       lifePayRateList.value.find(
         (x) => x.rateType === blLifeRecharge.constants.LifePayRateTypeEnum.榛樿鐢佃垂鎶樻墸
-      )?.rate ?? 1
-  );
+      )?.rate ?? 0
+    );
+  });
+
+  const lifePayGasRate = computed(() => {
+    if (hasChannel.value && channelRate.value.channlesRate) {
+      return channelRate.value.channlesRate;
+    }
+    return (
+      lifePayRateList.value.find(
+        (x) => x.rateType === blLifeRecharge.constants.LifePayRateTypeEnum.榛樿鐕冩皵鎶樻墸
+      )?.rate ?? 0
+    );
+  });
 
   return {
     lifePayRateList,
     lifePayPhoneRate,
     lifePayElectricRate,
+    lifePayGasRate,
   };
 }
 
@@ -50,10 +93,10 @@
   const { data: phoneParValueList, isLoading } = useQuery({
     queryKey: ['blLifeRecharge/getPhoneParValue'],
     queryFn: async () => {
-      return await blLifeRecharge.services.getPhoneParValue({ showLoading: false });
+      return await blLifeRecharge.services.getPhoneParValue({}, { showLoading: false });
     },
     select(data) {
-      return data.phoneParValue ?? [];
+      return data?.phoneParValue ?? [];
     },
     placeholderData: () => ({} as PhoneParValueResponse),
   });
@@ -67,14 +110,14 @@
   const { blLifeRecharge } = useLifeRechargeContext();
 
   const { data: electricParValueList, isLoading } = useQuery({
-    queryKey: ['blLifeRecharge/getElectricParValue'],
+    queryKey: ['blLifeRecharge/getElectricSupportArea'],
     queryFn: async () => {
-      return await blLifeRecharge.services.getElectricParValue({ showLoading: false });
+      return await blLifeRecharge.services.getElectricSupportArea({}, { showLoading: false });
     },
     select(data) {
-      return data.electricParValue ?? [];
+      return data.electricAreaList ?? [];
     },
-    placeholderData: () => ({} as ElectricParValueResponse),
+    placeholderData: () => ({} as ElectricSupportAreaResponse),
   });
 
   return {
@@ -96,7 +139,7 @@
   // });
 
   const { infiniteLoadingProps } = useInfiniteLoading(
-    ({ pageParam }) => {
+    async ({ pageParam }) => {
       let params: QueryLifePayOrderListInput = {
         pageModel: {
           rows: 20,
@@ -107,9 +150,18 @@
         userId: blLifeRecharge.accountModel.userId,
       };
 
-      return blLifeRecharge.services.getUserLifePayOrderPage(params, {
+      let res = await blLifeRecharge.services.getUserLifePayOrderPage(params, {
         showLoading: false,
       });
+      res.data = res.data.map((x) => ({
+        ...x,
+        frontStatus: convertOrderFrontStatus(
+          x.payStatus,
+          x.lifePayOrderStatus,
+          x.lifePayRefundStatus
+        ),
+      }));
+      return res;
     },
     {
       queryKey: [
@@ -119,6 +171,12 @@
           userId: blLifeRecharge.accountModel.userId,
         },
       ],
+
+      select(data) {
+        console.log('data: ', data);
+        //  data.pages.map((item) => item.data.map((x) => convertOrderFrontStatus(x)))
+        return data;
+      },
     }
   );
 
@@ -126,3 +184,156 @@
     infiniteLoadingProps,
   };
 }
+
+type UseUserAccountAllListOptions = {
+  lifePayOrderType: MaybeRef<LifeRechargeConstants.LifePayOrderTypeEnum>;
+  onSuccess?: (data: UserAccountListOutput[]) => any;
+};
+
+export function useUserAccountAllList({
+  lifePayOrderType,
+  onSuccess,
+}: UseUserAccountAllListOptions) {
+  const { blLifeRecharge } = useLifeRechargeContext();
+
+  const { data: userAccountAllList, isLoading } = useQuery({
+    queryKey: [
+      'blLifeRecharge/getUserAccountAllList',
+      blLifeRecharge.accountModel.userId,
+      lifePayOrderType,
+    ],
+    queryFn: async () => {
+      let params: QueryUserAccountAllListInput = {
+        userId: blLifeRecharge.accountModel.userId,
+        lifePayOrderType: unref(lifePayOrderType),
+      };
+      return await blLifeRecharge.services.getUserAccountAllList(params, { showLoading: false });
+    },
+    placeholderData: () => [] as UserAccountListOutput[],
+    onSuccess(data) {
+      onSuccess?.(data);
+    },
+  });
+
+  const queryClient = useQueryClient();
+
+  function invalidateQueries() {
+    return queryClient.invalidateQueries({
+      queryKey: [
+        'blLifeRecharge/getUserAccountAllList',
+        blLifeRecharge.accountModel.userId,
+        lifePayOrderType,
+      ],
+    });
+  }
+
+  return {
+    userAccountAllList,
+    isLoading,
+    invalidateQueries,
+  };
+}
+
+export function useAddUpdateUserAccount() {
+  const { blLifeRecharge } = useLifeRechargeContext();
+
+  const queryClient = useQueryClient();
+
+  function invalidateQueries(lifePayOrderType: LifeRechargeConstants.LifePayOrderTypeEnum) {
+    return queryClient.invalidateQueries({
+      queryKey: [
+        'blLifeRecharge/getUserAccountAllList',
+        blLifeRecharge.accountModel.userId,
+        lifePayOrderType,
+      ],
+    });
+  }
+
+  async function addUpdateUserAccount(params: AddUpdateUserAccountInput) {
+    let res = await blLifeRecharge.services.addUpdateUserAccount(params);
+    if (res) {
+      invalidateQueries(params.lifePayType);
+    }
+    return res;
+  }
+
+  return { addUpdateUserAccount };
+}
+
+type UseSetUserAccountBySelectOptions = {
+  lifePayOrderType: MaybeRef<LifeRechargeConstants.LifePayOrderTypeEnum>;
+  onSetUserAccount: (currentUserAccount: UserAccountListOutput) => any;
+};
+
+export function useSetUserAccountBySelect({
+  lifePayOrderType,
+  onSetUserAccount,
+}: UseSetUserAccountBySelectOptions) {
+  const { userAccountAllList } = useUserAccountAllList({
+    lifePayOrderType: lifePayOrderType,
+    onSuccess(data) {
+      if (data.length > 0) {
+        const currentUserAccount = data[0];
+        onSetUserAccount?.(currentUserAccount);
+      }
+    },
+  });
+
+  function handleUserAccountChange(val: string) {
+    const currentUserAccount = userAccountAllList.value.find((x) => x.id === val);
+    onSetUserAccount?.(currentUserAccount);
+  }
+
+  return {
+    handleUserAccountChange,
+    userAccountAllList,
+  };
+}
+
+export function useGetGasParValue() {
+  const { blLifeRecharge } = useLifeRechargeContext();
+
+  const { data: gasParValueList, isLoading } = useQuery({
+    queryKey: ['blLifeRecharge/getGasParValue'],
+    queryFn: async () => {
+      return await blLifeRecharge.services.getGasParValue({}, { showLoading: false });
+    },
+    select(data) {
+      return data?.gasParValue ?? [];
+    },
+    placeholderData: () => ({} as GasParValueResponse),
+  });
+
+  return {
+    gasParValueList,
+  };
+}
+
+type UseIntroInfoOptions = {
+  lifePayOrderType: MaybeRef<LifeRechargeConstants.LifePayOrderTypeEnum>;
+  onSuccess?: (data: API.LifePayIntroInfoOutput[]) => any;
+};
+
+export function useIntroInfo({ lifePayOrderType, onSuccess }: UseIntroInfoOptions) {
+  const { blLifeRecharge } = useLifeRechargeContext();
+
+  const { data: introInfo } = useQuery({
+    queryKey: ['blLifeRecharge/getIntroInfo', lifePayOrderType],
+    queryFn: async () => {
+      return await blLifeRecharge.services.getIntroInfo(
+        {
+          type: unref(lifePayOrderType),
+        },
+        {
+          showLoading: false,
+        }
+      );
+    },
+    placeholderData: () => [] as API.LifePayIntroInfoOutput[],
+    onSuccess: (data) => {
+      onSuccess?.(data);
+    },
+  });
+
+  return { introInfo };
+}

--
Gitblit v1.9.1