365 lines
10 KiB
TypeScript
365 lines
10 KiB
TypeScript
import { useDownloader } from "@/lib/hooks";
|
|
import { useList, UseListQueryResult, useOne, useSave } from "@/lib/hooks/useDataSource";
|
|
import { IGetListDataProviderParams } from "@/lib/hooks/useDataSource/DataSource";
|
|
import { TDataSourceError } from "@/lib/hooks/useDataSource/types";
|
|
import { useDataSource } from "@/lib/hooks/useDataSource/useDataSource";
|
|
import { useQueryKey } from "@/lib/hooks/useQueryKey";
|
|
import {
|
|
ICreateQuote_Request_DTO,
|
|
ICreateQuote_Response_DTO,
|
|
IDuplicateQuote_Response_DTO,
|
|
IGetQuote_Response_DTO,
|
|
IListQuotes_Response_DTO,
|
|
IListResponse_DTO,
|
|
ISendQuote_Request_DTO,
|
|
ISetStatusQuote_Request_DTO,
|
|
IUpdateQuote_Request_DTO,
|
|
IUpdateQuote_Response_DTO,
|
|
UniqueID,
|
|
} from "@shared/contexts";
|
|
import { useMutation, useQueryClient } from "@tanstack/react-query";
|
|
import { useCallback, useState } from "react";
|
|
import slugify from "slugify";
|
|
|
|
export type UseQuotesListParams = Omit<IGetListDataProviderParams, "filters" | "resource"> & {
|
|
status?: string;
|
|
enabled?: boolean;
|
|
queryOptions?: Record<string, unknown>;
|
|
};
|
|
|
|
export type UseQuotesListResponse = UseListQueryResult<
|
|
IListResponse_DTO<IListQuotes_Response_DTO>,
|
|
unknown
|
|
>;
|
|
|
|
export type UseQuotesGetParamsType = {
|
|
enabled?: boolean;
|
|
queryOptions?: Record<string, unknown>;
|
|
};
|
|
|
|
export type UseQuotesReportParamsType = {
|
|
enabled?: boolean;
|
|
queryOptions?: Record<string, unknown>;
|
|
};
|
|
|
|
export const useQuotes = () => {
|
|
const dataSource = useDataSource();
|
|
const keys = useQueryKey();
|
|
|
|
const getQuotePDFDownloadURL = useCallback(
|
|
(id: string) => `${dataSource.getApiUrl()}/quotes/${id}/report`,
|
|
[dataSource]
|
|
);
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const getQuotePDFFilename = useCallback(
|
|
(quote: IListQuotes_Response_DTO | IGetQuote_Response_DTO) =>
|
|
`quote-${slugify(quote.reference, {
|
|
lower: true, // Convierte a minúsculas
|
|
strict: true, // Elimina caracteres que no son letras o números
|
|
locale: "en", // Establece la localización para la conversión
|
|
trim: true, // Elimina espacios en blanco al principio y al final
|
|
})}.pdf`,
|
|
[]
|
|
);
|
|
|
|
const actions = {
|
|
useList: (params: UseQuotesListParams): UseQuotesListResponse => {
|
|
const dataSource = useDataSource();
|
|
const keys = useQueryKey();
|
|
|
|
const {
|
|
pagination,
|
|
status = "draft",
|
|
quickSearchTerm = undefined,
|
|
enabled = true,
|
|
queryOptions,
|
|
} = params;
|
|
|
|
return useList({
|
|
queryKey: keys().data().resource("quotes").action("list").params(params).get(),
|
|
queryFn: () => {
|
|
return dataSource.getList({
|
|
resource: "quotes",
|
|
quickSearchTerm,
|
|
filters:
|
|
status !== "all"
|
|
? [
|
|
{
|
|
field: "status",
|
|
operator: "eq",
|
|
value: status,
|
|
},
|
|
]
|
|
: undefined,
|
|
pagination,
|
|
});
|
|
},
|
|
enabled,
|
|
queryOptions,
|
|
});
|
|
},
|
|
|
|
useCreate: () => {
|
|
const queryClient = useQueryClient();
|
|
return useSave<ICreateQuote_Response_DTO, TDataSourceError, ICreateQuote_Request_DTO>({
|
|
//mutationKey: keys().data().resource("quotes").action("one").id("").params().get(),
|
|
mutationFn: (data) => {
|
|
const { date } = data;
|
|
|
|
const id = UniqueID.generateNewID().object.toString();
|
|
const status = "draft";
|
|
|
|
return dataSource.createOne({
|
|
resource: "quotes",
|
|
data: {
|
|
...data,
|
|
date: new Date(date).toISOString().slice(0, 10),
|
|
status,
|
|
id,
|
|
},
|
|
});
|
|
},
|
|
onSuccess: () => {
|
|
queryClient.invalidateQueries({
|
|
queryKey: ["data", "default", "quotes"],
|
|
});
|
|
},
|
|
});
|
|
},
|
|
|
|
useUpdate: (id: string) => {
|
|
const queryClient = useQueryClient();
|
|
|
|
return useMutation<IUpdateQuote_Response_DTO, TDataSourceError, IUpdateQuote_Request_DTO>({
|
|
mutationKey: keys().data().resource("quotes").action("one").id(id).params().get(),
|
|
mutationFn: (data) => {
|
|
return dataSource.updateOne({
|
|
resource: "quotes",
|
|
id,
|
|
data,
|
|
});
|
|
},
|
|
onSuccess: () => {
|
|
queryClient.invalidateQueries({
|
|
queryKey: ["data", "default", "quotes"],
|
|
});
|
|
},
|
|
});
|
|
},
|
|
|
|
useSetStatus: () => {
|
|
const queryClient = useQueryClient();
|
|
|
|
return useMutation<void, TDataSourceError, ISetStatusQuote_Request_DTO & { id: string }>({
|
|
mutationFn: (data) => {
|
|
const { id, newStatus } = data;
|
|
|
|
return dataSource.custom({
|
|
url: `${dataSource.getApiUrl()}/quotes/${id}/setStatus`,
|
|
method: "put",
|
|
data: {
|
|
newStatus,
|
|
},
|
|
});
|
|
},
|
|
onSuccess: () => {
|
|
queryClient.invalidateQueries({
|
|
queryKey: ["data", "default", "quotes"],
|
|
});
|
|
},
|
|
});
|
|
},
|
|
|
|
useDuplicate: () => {
|
|
const queryClient = useQueryClient();
|
|
|
|
return useMutation<IDuplicateQuote_Response_DTO, TDataSourceError, { id: string }>({
|
|
//mutationKey: keys().data().resource("quotes").action("one").id("").params().get(),
|
|
mutationFn: (data) => {
|
|
const { id } = data;
|
|
|
|
return dataSource.custom({
|
|
url: `${dataSource.getApiUrl()}/quotes/${id}/duplicate`,
|
|
method: "post",
|
|
});
|
|
},
|
|
onSuccess: () => {
|
|
queryClient.invalidateQueries({
|
|
queryKey: ["data", "default", "quotes"],
|
|
});
|
|
},
|
|
});
|
|
},
|
|
|
|
useSentTo: (id?: string) => {
|
|
const queryClient = useQueryClient();
|
|
|
|
return useMutation<void, TDataSourceError, ISendQuote_Request_DTO>({
|
|
mutationKey: keys().data().resource("quotes").action("one").id(id).params().get(),
|
|
mutationFn: (data) => {
|
|
const { sent_date } = data;
|
|
|
|
return dataSource.custom({
|
|
url: `${dataSource.getApiUrl()}/quotes/${id}/send`,
|
|
method: "put",
|
|
data: {
|
|
sent_date,
|
|
},
|
|
});
|
|
},
|
|
onSuccess: () => {
|
|
queryClient.invalidateQueries({
|
|
queryKey: ["data", "default", "quotes"],
|
|
});
|
|
},
|
|
});
|
|
},
|
|
|
|
useOne: (id?: string, params?: UseQuotesGetParamsType) =>
|
|
useOne<IGetQuote_Response_DTO>({
|
|
queryKey: keys().data().resource("quotes").action("one").id(id).params().get(),
|
|
queryFn: () =>
|
|
dataSource.getOne({
|
|
resource: "quotes",
|
|
id: String(id),
|
|
}),
|
|
enabled: !!id,
|
|
...params,
|
|
}),
|
|
|
|
/*useReport2: (id?: string, params?: UseQuotesReportParamsType) => {
|
|
const queryClient = useQueryClient();
|
|
const queryKey = useMemo(
|
|
() => keys().data().resource("quotes").action("report").id(id).params().get(),
|
|
[id]
|
|
);
|
|
|
|
return {
|
|
...useCustom<ArrayBuffer, TDataSourceError, IReportQuote_Response_DTO>({
|
|
queryKey,
|
|
queryFn: ({ signal }) =>
|
|
dataSource.custom({
|
|
url: `${dataSource.getApiUrl()}/quotes/${id}/report`,
|
|
method: "get",
|
|
responseType: "arraybuffer",
|
|
signal,
|
|
}),
|
|
|
|
enabled: !!id,
|
|
select: useCallback(
|
|
(data: ArrayBuffer) => ({
|
|
original: data,
|
|
data: new Uint8Array(data),
|
|
}),
|
|
[]
|
|
),
|
|
...params,
|
|
}),
|
|
cancelQuery: () => queryClient.cancelQueries({ queryKey }),
|
|
};
|
|
},*/
|
|
|
|
getQuotePDFDownloadURL,
|
|
|
|
getQuotePDFFilename,
|
|
|
|
/*useDownload2: (id?: string, params?: UseQuotesReportParamsType) => {
|
|
const queryKey = useMemo(
|
|
() => keys().data().resource("quotes").action("report").id(id).params().get(),
|
|
[id]
|
|
);
|
|
|
|
const { data, error, refetch, isFetching, isError } = useCustom<
|
|
IDownloadPDFDataProviderResponse,
|
|
TDataSourceError
|
|
>({
|
|
queryKey,
|
|
queryFn: () =>
|
|
dataSource.downloadPDF({
|
|
url: `${dataSource.getApiUrl()}/quotes/${id}/report`,
|
|
}),
|
|
|
|
enabled: false,
|
|
refetchInterval: false,
|
|
...params,
|
|
});
|
|
|
|
const download = () => {
|
|
console.log("pido");
|
|
refetch().then((result) => {
|
|
console.log("termino");
|
|
if (result.isSuccess) {
|
|
const blob = data!.filedata;
|
|
const link = document.createElement("a");
|
|
const url = window.URL.createObjectURL(blob);
|
|
link.href = url;
|
|
link.setAttribute("download", data!.filename); // Nombre del archivo
|
|
document.body.appendChild(link);
|
|
link.click();
|
|
link.remove();
|
|
window.URL.revokeObjectURL(url);
|
|
}
|
|
});
|
|
};
|
|
|
|
return { download, error, isFetching, isError };
|
|
},*/
|
|
|
|
useReport: () => {
|
|
const auth = dataSource.getApiAuthorization();
|
|
const [report, setReport] = useState<Blob | undefined>(undefined);
|
|
|
|
const { download, ...rest } = useDownloader({
|
|
headers: {
|
|
Authorization: auth,
|
|
},
|
|
customHandleDownload: useCallback(
|
|
(data: Blob) => {
|
|
const blobData = [data];
|
|
const blob = new Blob(blobData, {
|
|
type: "application/octet-stream",
|
|
});
|
|
setReport(blob);
|
|
return true;
|
|
},
|
|
[setReport]
|
|
),
|
|
});
|
|
|
|
const preview = useCallback(
|
|
(id: string) => {
|
|
return download(actions.getQuotePDFDownloadURL(id), "");
|
|
},
|
|
[download]
|
|
);
|
|
|
|
return {
|
|
...rest,
|
|
preview,
|
|
report,
|
|
};
|
|
},
|
|
|
|
useDownloader: () => {
|
|
const auth = dataSource.getApiAuthorization();
|
|
const downloader = useDownloader({
|
|
headers: {
|
|
Authorization: auth,
|
|
},
|
|
});
|
|
|
|
const download = (id: string, filename: string) => {
|
|
const url = actions.getQuotePDFDownloadURL(id);
|
|
return downloader.download(url, filename);
|
|
};
|
|
|
|
return {
|
|
...downloader,
|
|
download,
|
|
};
|
|
},
|
|
};
|
|
return actions;
|
|
};
|