import { useQuery, useQueryClient } from '@tanstack/vue-query';
|
import * as standardServiceServices from '@12333/services/apiV2/standardService';
|
import * as standardOrderServices from '@12333/services/apiV2/standardOrder';
|
import { computed, MaybeRef, reactive, unref } from 'vue';
|
import { groupBy } from 'lodash';
|
import { useInfiniteLoading } from '@12333/hooks';
|
import { EnumStandardOrderAppointmentStatus, EnumStandardOrderPayStatus } from '@12333/constants';
|
|
type UseStandardServiceDetailOptions = {
|
id: MaybeRef<string>;
|
onSuccess?: (data: API.GetStandardServiceQueryResult) => any;
|
};
|
|
export function useStandardServiceDetail({ id, onSuccess }: UseStandardServiceDetailOptions) {
|
const { data, refetch, isLoading, isError } = useQuery({
|
queryKey: ['standardServiceServices/getStandardService', id],
|
queryFn: async () => {
|
let params: API.APIgetStandardServiceParams = {
|
id: unref(id),
|
};
|
|
return await standardServiceServices.getStandardService(params, {
|
showLoading: false,
|
});
|
},
|
placeholderData: () => ({} as API.GetStandardServiceQueryResult),
|
onSuccess(data) {
|
onSuccess?.(data);
|
},
|
});
|
|
const minPrice = computed(() => {
|
if (!data.value?.specs?.length) {
|
return 0;
|
} else {
|
return Math.min(...data.value.specs.map((x) => x.price));
|
}
|
});
|
|
return {
|
detail: data,
|
refetch,
|
isLoading,
|
isError,
|
minPrice,
|
};
|
}
|
|
type UseStandardServiceListOptions = {
|
params?: MaybeRef<API.GetOpenStandardServiceListQuery>;
|
onSuccess?: (data: API.GetStandardServicesQueryResultItem[]) => any;
|
};
|
|
export function useStandardServiceList(options: UseStandardServiceListOptions = {}) {
|
const { params = {}, onSuccess } = options;
|
const {
|
data: standardServiceList,
|
refetch,
|
isLoading,
|
isError,
|
} = useQuery({
|
queryKey: ['standardServiceServices/getOpenStandardServiceList', params],
|
queryFn: async () => {
|
return await standardServiceServices.getOpenStandardServiceList(unref(params), {
|
showLoading: false,
|
});
|
},
|
placeholderData: () => [] as API.GetStandardServicesQueryResultItem[],
|
onSuccess(data) {
|
onSuccess?.(data);
|
},
|
});
|
|
const standardServiceListForCategory = computed(() => {
|
return standardServiceList.value.map((x) => ({
|
...x,
|
catName: x.name,
|
}));
|
});
|
|
const standardServiceListForCategoryMap = computed(() => {
|
const group = groupBy(standardServiceListForCategory.value, 'jobCode');
|
return group;
|
});
|
|
const queryClient = useQueryClient();
|
|
function ensureStandardServiceList() {
|
return queryClient.ensureQueryData<API.GetStandardServicesQueryResultItem[]>({
|
queryKey: ['standardServiceServices/getOpenStandardServiceList', params],
|
});
|
}
|
|
return {
|
standardServiceList,
|
ensureStandardServiceList,
|
standardServiceListForCategory,
|
standardServiceListForCategoryMap,
|
};
|
}
|
|
export function useGetStandardOrders() {
|
const queryState = reactive({
|
appointmentStatus: 0 as any as EnumStandardOrderAppointmentStatus,
|
payStatus: 0 as any as EnumStandardOrderPayStatus,
|
});
|
|
const { infiniteLoadingProps } = useInfiniteLoading(
|
({ pageParam }) => {
|
let params: API.GetStandardOrdersQuery = {
|
pageModel: {
|
rows: 20,
|
page: pageParam,
|
},
|
};
|
|
if (queryState.appointmentStatus) {
|
params.appointmentStatus = queryState.appointmentStatus;
|
}
|
if (queryState.payStatus) {
|
params.payStatus = queryState.payStatus;
|
}
|
|
return standardOrderServices.getStandardOrders(params, {
|
showLoading: false,
|
});
|
},
|
{
|
queryKey: ['standardOrderServices/getStandardOrders', queryState],
|
}
|
);
|
|
return {
|
queryState,
|
infiniteLoadingProps,
|
};
|
}
|
|
type UseStandardOrderOptions = {
|
id: MaybeRef<string>;
|
onSuccess?: (data: API.GetStandardOrderQueryResult) => any;
|
};
|
|
export function useStandardOrder({ id, onSuccess }: UseStandardOrderOptions) {
|
const {
|
isLoading,
|
isError,
|
data: detail,
|
refetch,
|
} = useQuery({
|
queryKey: ['standardOrderServices/getStandardOrder', id],
|
queryFn: async () => {
|
const params: API.APIgetStandardOrderParams = {
|
id: unref(id),
|
};
|
return await standardOrderServices.getStandardOrder(params, {
|
showLoading: false,
|
});
|
},
|
placeholderData: () => ({} as API.GetStandardOrderQueryResult),
|
onSuccess(data) {
|
onSuccess?.(data);
|
},
|
});
|
|
return { detail, isLoading, isError, refetch };
|
}
|
