@omniumretail/shared-resources 0.3.85 → 0.3.86

package/src/hooks/Asta/Actions/get/getActionQuery.hook.ts

@@ -0,0 +1,29 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Actions, ResponseList } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export interface ActionQueryProps extends UseQueryOptions<ResponseList<"Value", Actions>> {
+    tags?: string;
+    page?: number;
+    records?: number;
+    sortBy?: string;
+    sortDirection?: string;
+    query?: string;
+}
+
+export const getActionQueryHook = ({ tags, page, records, sortBy, sortDirection, query }: ActionQueryProps) => {
+    return useQuery(
+        ['ACTION_QUERY', tags, page, records, sortBy, sortDirection, query],
+            () => getAuth0<ResponseList<"Value", Actions>>('/ASTA/Actions/GetByQuery', {
+                pPage: page || 1,
+                pRecords: records || 50,
+                pSortBy: sortBy || 'Type',
+                pSortDirection: sortDirection || 'asc',
+                pTerms: tags,
+                pQuery: query
+            }),
+            {
+                keepPreviousData: true,
+            }
+    );
+}

package/src/hooks/Asta/Actions/get/getActionStagesQuery.hook.ts

@@ -0,0 +1,10 @@
+import { useQuery } from "@tanstack/react-query";
+import { HeadersInterface } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export const getActionStageQueryHook = () => {
+    return useQuery(
+        ['ACTION_STAGES_QUERY'],
+        () => getAuth0<HeadersInterface[]>(`/ASTA/Actions/ActionsStatus`),
+    );
+}

package/src/hooks/Asta/Actions/mutate/useActionMutateQuery.hook.ts

@@ -0,0 +1,20 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Actions } from '../../../../interfaces';
+import { putAuth0, postAuth0 } from '../../../../services/ApiService';
+
+export const useActionMutateHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Actions, unknown, Actions>((data: Actions) => {
+        return data.Id ?
+            putAuth0(`/ASTA/Actions?`, {
+                pId: data.Id
+            }, data)
+
+            : postAuth0('/ASTA/Actions', undefined, data);
+    }, {
+        onSuccess: (data: Actions) => {
+            queryClient.setQueryData(
+                ['ACTIONS_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Actions/others/archiveActionQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Actions } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export interface ActionTemplateProps extends UseQueryOptions<Actions> {
+    actionsIds: string[];
+}
+
+export const archiveActionQueryHook = ({ actionsIds }: ActionTemplateProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<Actions, unknown, string[]>(() => {
+        return putAuth0(`/ASTA/Actions/FileActionList`, undefined, actionsIds);
+    }, {
+        onSuccess: (data: Actions) => {
+            queryClient.setQueryData(
+                ['ACTION_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Actions/others/deleteActionQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Actions } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export interface DeleteActionProps extends UseQueryOptions<Actions> {
+    actionsIds: string[];
+}
+
+export const deleteActionMutateHook = ({ actionsIds }: DeleteActionProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<Actions, unknown, string[]>(() => {
+        return putAuth0(`/ASTA/Actions/DeleteActionList`, undefined, actionsIds)
+    }, {
+        onSuccess: () => {
+            queryClient.invalidateQueries(
+                ['ACTION_QUERY']);
+        },
+    });
+}

package/src/hooks/Asta/Actions/others/extractActionQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Actions } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export interface ExtractActionProps extends UseQueryOptions<Actions> {
+    actionsIds: string[];
+}
+
+export const extractActionQueryHook = ({ actionsIds }: ExtractActionProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<Actions, unknown, string[]>(() => {
+        return putAuth0(`/ASTA/Actions/FinishedActionList`, undefined, actionsIds)
+    }, {
+        onSuccess: (data: Actions) => {
+            queryClient.setQueryData(
+                ['ACTION_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Actions/others/finishActionQuery.hook.ts

@@ -0,0 +1,17 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Actions } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const finishActionQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Actions, unknown, Actions>((data: Actions) => {
+        return putAuth0(`/ASTA/Actions/FinishAction?`, {
+            pId: data.Id
+        }, data);
+    }, {
+        onSuccess: (data: Actions) => {
+            queryClient.setQueryData(
+                ['ACTION_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Actions/others/selectActionStatusQuery.hook.ts

@@ -0,0 +1,18 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Actions } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const selectActionStatusQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Actions, unknown, Actions>((data: Actions) => {
+        return putAuth0(`/ASTA/Actions/SelectStatus?`, {
+            pActionId: data.Id,
+            pStatus: data.Stage
+        }, data);
+    }, {
+        onSuccess: (data: Actions) => {
+            queryClient.setQueryData(
+                ['ACTION_STATUS_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Actions/others/startActionQuery.hook.ts

@@ -0,0 +1,17 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Actions } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const startActionQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Actions, unknown, Actions>((data: Actions) => {
+        return putAuth0(`/ASTA/Actions/StartAction?`, {
+            pId: data.Id
+        }, data);
+    }, {
+        onSuccess: (data: Actions) => {
+            queryClient.setQueryData(
+                ['ACTION_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Answer/get/getAstaAnswerByIdQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useQuery } from "@tanstack/react-query";
+import { Answer } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export const getAnswerByIdQueryHook = (answerId: string) => {
+    return useQuery(
+        ['ANSWER_ID_QUERY', answerId],
+        () => getAuth0<Answer>(`/ASTA/Answers/GetAnswerById`, {
+            pId: answerId
+        }),
+        {
+            enabled: !!(answerId),
+        },
+    );
+}

package/src/hooks/Asta/Answer/get/getAstaAnswerQuery.hook.ts

@@ -0,0 +1,29 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Answer, ResponseList } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export interface AstaAnswersQueryProps extends UseQueryOptions<ResponseList<"Answers", Answer>> {
+    tags?: string;
+    page?: number;
+    records?: number;
+    sortBy?: string;
+    sortDirection?: string;
+    query?: string;
+}
+
+export const getAstaAnswersQueryHook = ({ tags, page, records, sortBy, sortDirection, query }: AstaAnswersQueryProps) => {
+    return useQuery(
+        ['ASTA_ANSWERS_QUERY', tags, page, records, sortBy, sortDirection, query],
+            () => getAuth0<ResponseList<"Answers", Answer>>('/ASTA/Answers/GetAnswers', {
+                pPage: page || 1,
+                pRecords: records || 50,
+                pSortBy: sortBy || 'Type',
+                pSortDirection: sortDirection || 'asc',
+                pTerms: tags,
+                pQuery: query
+            }),
+            {
+                keepPreviousData: true,
+            }
+    );
+}

package/src/hooks/Asta/Answer/mutate/useAstaAnswersMutateQuery.hook.ts

@@ -0,0 +1,20 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Answer } from '../../../../interfaces';
+import { putAuth0, postAuth0 } from '../../../../services/ApiService';
+
+export const useAstaAnswersMutateHook = (inspectionId: string, answerId: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<Answer, unknown, Answer>((data: Answer) => {
+        return inspectionId === "" ?
+            putAuth0(`/ASTA/Answers/${answerId}`, undefined, data)
+
+            : postAuth0(`/ASTA/Answers?`, {
+                pInspectionId: inspectionId
+            }, data);
+    }, {
+        onSuccess: (data: Answer) => {
+            queryClient.setQueryData(
+                ['ASTA_ANSWERS_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Answer/others/finishAstaAnswersQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Answer } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const finishAstaAnswersQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Answer, unknown, Answer>((data: Answer) => {
+        return putAuth0(`/ASTA/Answers/FinishInspectionAnswer/${data.Id}`, undefined, data)
+    }, {
+        onSuccess: (data: Answer) => {
+            queryClient.setQueryData(
+                ['ASTA_ANSWERS_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Answer/others/finishGNGAstaAnswersQuery.hook.ts

@@ -0,0 +1,18 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Answer } from '../../../../interfaces';
+import { postAuth0 } from '../../../../services/ApiService';
+
+export const finishGNGAstaAnswersQueryHook = (answerId: string, userName: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<Answer, unknown, Answer>((data: Answer) => {
+        return postAuth0(`/ASTA/Audit?`, {
+            pInspectionAnswerId: answerId,
+            pUserName: userName
+        }, data)
+    }, {
+        onSuccess: (data: Answer) => {
+            queryClient.setQueryData(
+                ['ASTA_GNG_ANSWERS_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Answer/others/putAnswerImageQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Answer } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const putAnswerImageMutateHook = (questionnaireId: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<Answer, unknown, Answer>((data: Answer) => {
+        return putAuth0(`/ASTA/Answers/Image/${questionnaireId}`, undefined, data)
+    }, {
+        onSuccess: (data: Answer) => {
+            queryClient.setQueryData(
+                ['ASTA_ANSWER_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Answer/others/sendInspectionEmailQuery.hook.ts

@@ -0,0 +1,21 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const sendInspectionEmailMutateHook = (answerId: string, userName: string, email: string, storeId: string, pdfUrl: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, Inspection>((data: Inspection) => {
+        return putAuth0(`/ASTA/Answers/SendEmail?`, {
+            pAnswerId: answerId,
+            pUserName: userName,
+            pEmail: email,
+            pStoreId: storeId,
+            pPDFUrl: pdfUrl
+        }, data);
+    }, {
+        onSuccess: (data: Inspection) => {
+            queryClient.setQueryData(
+                ['SEND_INSPECTION_EMAIL_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Answer/others/sendInspectionEmailStoreQuery.hook.ts

@@ -0,0 +1,20 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const sendInspectionEmailStoreMutateHook = (answerId: string, userName: string, storeId: string, pdfUrl: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, Inspection>((data: Inspection) => {
+        return putAuth0(`/ASTA/Answers/SendEmailStore?`, {
+            pAnswerId: answerId,
+            pUserName: userName,
+            pStoreId: storeId,
+            pPDFUrl: pdfUrl
+        }, data);
+    }, {
+        onSuccess: (data: Inspection) => {
+            queryClient.setQueryData(
+                ['SEND_INSPECTION_EMAIL_STORE_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/AnswerType/get/getAllAnswerTypeQuery.hook.ts

@@ -0,0 +1,29 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { AnswerType, ResponseList } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export interface AnswerTypeQueryProps extends UseQueryOptions<ResponseList<"Value", AnswerType>> {
+    tags?: string;
+    page?: number;
+    records?: number;
+    sortBy?: string;
+    sortDirection?: string;
+    query?: string;
+}
+
+export const getAllAnswerTypeQueryHook = ({ tags, page, records, sortBy, sortDirection, query }: AnswerTypeQueryProps) => {
+    return useQuery(
+        ['ALL_ANSWER_TYPE_QUERY', tags, page, records, sortBy, sortDirection, query],
+            () => getAuth0<ResponseList<"Value", AnswerType>>('/ASTA/AnswerType/GetByQuery', {
+                pPage: page || 1,
+                pRecords: records || 50,
+                pSortBy: sortBy || 'Type',
+                pSortDirection: sortDirection || 'asc',
+                pTerms: tags,
+                pQuery: query
+            }),
+            {
+                keepPreviousData: true,
+            }
+    );
+}

package/src/hooks/Asta/AnswerType/get/getAnswerColorsQuery.hook.ts

@@ -0,0 +1,10 @@
+import { useQuery } from "@tanstack/react-query";
+import { HeadersInterface } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export const getAnswerColorsQueryHook = () => {
+    return useQuery(
+        ['ANSWER_COLORS_QUERY'],
+        () => getAuth0<HeadersInterface[]>(`/ASTA/AnswerType/Colors`),
+    );
+}

package/src/hooks/Asta/AnswerType/get/getAnswerTypeByIdQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useQuery } from "@tanstack/react-query";
+import { AnswerType } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export const getAnswerTypeByIdQueryHook = (answerTypeId: string) => {
+    return useQuery(
+        ['ANSWER_TYPE_ID_QUERY', answerTypeId],
+        () => getAuth0<AnswerType>(`/ASTA/AnswerType/GetById`, {
+            pId: answerTypeId
+        }),
+        {
+            enabled: !!(answerTypeId),
+        },
+    );
+}

package/src/hooks/Asta/AnswerType/get/getAnswerTypeQuery.hook.ts

@@ -0,0 +1,10 @@
+import { useQuery } from "@tanstack/react-query";
+import { AnswerType } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export const getAnswerTypeQueryHook = () => {
+    return useQuery(
+        ['ANSWER_TYPE_QUERY'],
+        () => getAuth0<AnswerType[]>(`/ASTA/AnswerType`),
+    );
+}

package/src/hooks/Asta/AnswerType/mutate/useAnswerTypeMutateQuery.hook.ts

@@ -0,0 +1,20 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { AnswerType } from '../../../../interfaces';
+import { putAuth0, postAuth0 } from '../../../../services/ApiService';
+
+export const useAnswerTypeMutateHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<AnswerType, unknown, AnswerType>((data: AnswerType) => {
+        return data.Id ?
+            putAuth0(`/ASTA/AnswerType?`, {
+                pId: data.Id
+            }, data)
+
+            : postAuth0('/ASTA/AnswerType', undefined, data);
+    }, {
+        onSuccess: (data: AnswerType) => {
+            queryClient.setQueryData(
+                ['ANSWER_TYPE_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/AnswerType/others/deleteAnswerTypeQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { AnswerType } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export interface DeleteAnswerTypeProps extends UseQueryOptions<AnswerType> {
+    answerTypeIds: string[];
+}
+
+export const deleteAnswerTypeHook = ({ answerTypeIds }: DeleteAnswerTypeProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<AnswerType, unknown, string[]>(() => {
+        return putAuth0(`/ASTA/AnswerType/Delete`, undefined, answerTypeIds)
+    }, {
+        onSuccess: () => {
+            queryClient.invalidateQueries(
+                ['ALL_ANSWER_TYPE_QUERY']);
+        },
+    });
+}

package/src/hooks/Asta/AnswerType/others/finishAnswerTypeQuery.hook.ts

@@ -0,0 +1,17 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { AnswerType } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const finishAnswerTypeQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<AnswerType, unknown, AnswerType>((data: AnswerType) => {
+        return putAuth0(`/ASTA/AnswerType/Finished?`, {
+            pId: data.Id
+        }, data);
+    }, {
+        onSuccess: (data: AnswerType) => {
+            queryClient.setQueryData(
+                ['ANSWER_TYPE_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/AnswerType/others/selectAnswerNameQuery.hook.ts

@@ -0,0 +1,18 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { AnswerType } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const selectAnswerNameQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<AnswerType, unknown, AnswerType>((data: AnswerType) => {
+        return putAuth0(`/ASTA/AnswerType/SelectName?`, {
+            pAnswerTypeId: data.Id,
+            pUseName: data.UseName
+        }, data);
+    }, {
+        onSuccess: (data: AnswerType) => {
+            queryClient.setQueryData(
+                ['ANSWER_NAME_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Inspection/get/getInspectionQuery.hook.ts

@@ -0,0 +1,29 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Inspection, ResponseList } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export interface InspectionQueryProps extends UseQueryOptions<ResponseList<"Value", Inspection>> {
+    tags?: string;
+    page?: number;
+    records?: number;
+    sortBy?: string;
+    sortDirection?: string;
+    query?: string;
+}
+
+export const getInspectionQueryHook = ({ tags, page, records, sortBy, sortDirection, query }: InspectionQueryProps) => {
+    return useQuery(
+        ['INSPECTION_QUERY', tags, page, records, sortBy, sortDirection, query],
+            () => getAuth0<ResponseList<"Value", Inspection>>('/ASTA/Inspection/GetInspection', {
+                pPage: page || 1,
+                pRecords: records || 50,
+                pSortBy: sortBy || 'Type',
+                pSortDirection: sortDirection || 'asc',
+                pTerms: tags,
+                pQuery: query
+            }),
+            {
+                keepPreviousData: true,
+            }
+    );
+}

package/src/hooks/Asta/Inspection/mutate/useInspectionMutateQuery.hook.ts

@@ -0,0 +1,24 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { putAuth0, postAuth0 } from '../../../../services/ApiService';
+
+export const useInspectionMutateHook = (templateId: string, userId: string, userName: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, Inspection>((data: Inspection) => {
+        return data.Id ?
+            putAuth0(`/ASTA/Inspection/FileInspection?`, {
+                pId: data.Id
+            }, data) :
+
+            postAuth0(`/ASTA/Inspection?`, {
+                pId: templateId,
+                pUserId: userId,
+                pUserName: userName
+            } , data);
+    }, {
+        onSuccess: (data: Inspection) => {
+            queryClient.setQueryData(
+                ['INSPECTION_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Inspection/others/archiveTemplateQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export interface ArchiveInspectionProps extends UseQueryOptions<Inspection> {
+    inspectionIds: string[];
+}
+
+export const archiveInspectionQueryHook = ({ inspectionIds }: ArchiveInspectionProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, string[]>(() => {
+        return putAuth0(`/ASTA/Inspection/FileInspectionList`, undefined, inspectionIds);
+    }, {
+        onSuccess: (data: Inspection) => {
+            queryClient.setQueryData(
+                ['INSPECTION_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Inspection/others/deleteInspectionQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export interface DeleteInspectionProps extends UseQueryOptions<Inspection> {
+    inspectionIds: string[];
+}
+
+export const deleteInspectionMutateHook = ({ inspectionIds }: DeleteInspectionProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, string[]>(() => {
+        return putAuth0(`/ASTA/Inspection/DeleteInspectionList`, undefined, inspectionIds)
+    }, {
+        onSuccess: () => {
+            queryClient.invalidateQueries(
+                ['INSPECTION_QUERY']);
+        },
+    });
+}

package/src/hooks/Asta/Inspection/others/exportInspectionQuery.hook.ts

@@ -0,0 +1,19 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { postAuth0 } from '../../../../services/ApiService';
+
+export const exportInspectionMutateHook = (inspectionId: string, userName: string, language?: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, Inspection>((data: Inspection) => {
+        return postAuth0(`/ASTA/Inspection/AnswerExport?`, {
+            pInspectionId: inspectionId,
+            pUserName: userName,
+            pLanguage: language || "PT"
+        }, data);
+    }, {
+        onSuccess: (data: Inspection) => {
+            queryClient.setQueryData(
+                ['EXPORT_INSPECTION_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Inspection/others/extractTemplateQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export interface ExtractInspectionProps extends UseQueryOptions<Inspection> {
+    inspectionIds: string[];
+}
+
+export const extractInspectionQueryHook = ({ inspectionIds }: ExtractInspectionProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, string[]>(() => {
+        return putAuth0(`/ASTA/Inspection/FinishedInspectionList`, undefined, inspectionIds)
+    }, {
+        onSuccess: (data: Inspection) => {
+            queryClient.setQueryData(
+                ['INSPECTION_ID_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Asta/Inspection/others/finishInspectionQuery.hook.ts

@@ -0,0 +1,17 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Inspection } from '../../../../interfaces';
+import { putAuth0 } from '../../../../services/ApiService';
+
+export const finishInspectionQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Inspection, unknown, Inspection>((data: Inspection) => {
+        return putAuth0(`/ASTA/Inspection/FinishInspection?`, {
+            pId: data.Id
+        }, data)
+    }, {
+        onSuccess: (data: Inspection) => {
+            queryClient.setQueryData(
+                ['INSPECTION_ID_QUERY'], data);
+        },
+    });
+}