@omniumretail/shared-resources 0.3.85 → 0.3.86

package/src/hooks/Orch/others/stopInstanceQuery.hook.ts

@@ -0,0 +1,16 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { putAuth0 } from '../../../services/ApiService';
+
+export const stopInstanceQuery = (instanceId: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<any, unknown, any>(() => {
+        return putAuth0(`/ORQ/Instances/Stop?`, {
+            pId: instanceId,
+        })
+    }, {
+        onSuccess: (data) => {
+            queryClient.setQueryData(
+                ['STOP_INSTANCE_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Orch/others/updateMacroStatusQuery.hook.ts

@@ -0,0 +1,23 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { TransferPickProducts } from '../../../interfaces/TransferPickProducts';
+import { postAuth0 } from '../../../services/ApiService';
+
+export interface UpdateMacroStatusProps {
+    macroId: string;
+    status: string;
+}
+
+export const updateMacroStatusQueryHook = ({ macroId, status }: UpdateMacroStatusProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<TransferPickProducts, unknown>(() => {
+        return postAuth0(`/ORQ/Macros/UpdateStatus?`, {
+            pMacroId: macroId,
+            pStatus: status
+        });
+    }, {
+        onSuccess: (data) => {
+            queryClient.setQueryData(
+                ['UPDATE_STATUS_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/Vacation/get/getVacationPlanQuery.hook.ts

@@ -0,0 +1,20 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { VacationPlan, ResponseList } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+interface VacationPlanProps extends Omit<UseQueryOptions<ResponseList<"VacationPlans", VacationPlan>>, "queryKey"> {
+    page?: number;
+    records?: number;
+    userId: string;
+}
+
+export const getVacationPlanQueryHook = ({ page, records, userId, ...options }: VacationPlanProps) => {
+    return useQuery(
+        ['VACATION_PLAN_QUERY', page, records, userId, options],
+        () => getAuth0<ResponseList<"VacationPlans", VacationPlan>>(`/AACP/UserVacationPlans/${userId}`, {
+            pPage: page || 1,
+            pRecords: records || 50
+        }),
+        options
+    );
+}

package/src/hooks/Others/Vacation/get/getVacationTemplateQuery.hook.ts

@@ -0,0 +1,11 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { VacationPlan } from "../../../../interfaces";
+import { getAuth0 } from "../../../../services/ApiService";
+
+export const getVacationTemplateQueryHook = ({ ...options }: UseQueryOptions) => {
+    return useQuery(
+        ['VACATION_TEMPLATE_QUERY', options],
+        () => getAuth0<VacationPlan>(`/AACP/UserVacationPlans/Template`),
+        options
+    );
+}

package/src/hooks/Others/Vacation/others/aproveVacationPlanQuery.hook.ts

@@ -0,0 +1,23 @@
+import { useMutation, useQueryClient, UseQueryOptions } from "@tanstack/react-query";
+import { VacationPlan } from "../../../../interfaces";
+import { putAuth0 } from "../../../../services/ApiService";
+
+interface ApproveVacationPlanProps extends UseQueryOptions<VacationPlan> {
+    userId: string;
+    vacationPlan: string;
+}
+
+export const approveVacationPlanQueryHook = ({ vacationPlan, userId }: ApproveVacationPlanProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<VacationPlan, unknown, VacationPlan>((data: VacationPlan) => {
+        return putAuth0(`/AACP/UserVacationPlans/${vacationPlan}/Approve?`, {
+            pUserId: userId
+        }, data);
+    }, {
+        onSuccess: (data: VacationPlan) => {
+            queryClient.setQueryData(
+                ['APROVE_VACATION_PLAN_QUERY'], data);
+        },
+    });
+}
+

package/src/hooks/Others/Vacation/others/postVacationPlanQuery.hook.ts

@@ -0,0 +1,20 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { VacationPlan } from "../../../../interfaces";
+import { postAuth0 } from "../../../../services/ApiService";
+
+export interface PostVacationPlanProps extends UseQueryOptions<VacationPlan> {
+    userId: string;
+    bodyType?: string;
+}
+
+export const postVacationPlanQueryHook = ({ userId, bodyType }: PostVacationPlanProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<VacationPlan, unknown, VacationPlan>((data: VacationPlan | any) => {
+        return postAuth0(`/AACP/UserVacationPlans/${userId}`, undefined, data, bodyType);
+    }, {
+        onSuccess: (data: VacationPlan) => {
+            queryClient.setQueryData(
+                ['POST_VACATION_PLAN_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/Vacation/others/rejectVacationPlanQuery.hook.ts

@@ -0,0 +1,25 @@
+import { useMutation, useQueryClient, UseQueryOptions } from "@tanstack/react-query";
+import { VacationPlan } from "../../../../interfaces";
+import { putAuth0 } from "../../../../services/ApiService";
+
+interface RejectVacationPlanProps extends UseQueryOptions<VacationPlan> {
+    userId: string;
+    vacationPlan: string;
+    notes: string;
+}
+
+export const rejectVacationPlanQueryHook = ({ vacationPlan, userId, notes }: RejectVacationPlanProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<VacationPlan, unknown, VacationPlan>((data: VacationPlan) => {
+        return putAuth0(`/AACP/UserVacationPlans/${vacationPlan}/Reject?`, {
+            pUserId: userId,
+            pNotes: notes
+        }, data);
+    }, {
+        onSuccess: (data: VacationPlan) => {
+            queryClient.setQueryData(
+                ['REJECT_VACATION_PLAN_QUERY'], data);
+        },
+    });
+}
+

package/src/hooks/Others/changePasswordQuery.hook.ts

@@ -0,0 +1,21 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { putAuth0 } from "../../services/ApiService";
+
+export interface ChangePasswordProps {
+    userId: string;
+    password: string;
+}
+
+export const changePasswordQueryHook = ({ userId, password }: ChangePasswordProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<boolean, unknown>(() => {
+        return putAuth0(`/AACP/Users/${userId}/changePassword?`, {
+            pPassword: password
+        });
+    }, {
+        onSuccess: (data) => {
+            queryClient.setQueryData(
+                ['CHANGE_PASSWORD_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/editAllBellNotificationsStatusQuery.hook.ts

@@ -0,0 +1,19 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { BellNotification } from '../../interfaces';
+import { putAuth0 } from '../../services/ApiService';
+
+export interface editAllBellNotificationStatusProps extends UseQueryOptions<BellNotification> {
+    userId: string;
+}
+
+export const editAllBellNotificationStatusQueryHook = ({ userId }: editAllBellNotificationStatusProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<BellNotification, unknown, BellNotification>((data: BellNotification) => {
+        return putAuth0(`/ANOT/Notifications/${userId}/ReadAll`, undefined, data);
+    }, {
+        onSuccess: (data: BellNotification) => {
+            queryClient.setQueryData(
+                ['BELL_NOTIFICATION_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/editBellNotificationsStatusQuery.hook.ts

@@ -0,0 +1,22 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { BellNotification } from '../../interfaces';
+import { putAuth0 } from '../../services/ApiService';
+
+export interface editBellNotificationStatusProps extends UseQueryOptions<BellNotification> {
+    userId: string;
+    notificationId: string;
+}
+
+export const editBellNotificationStatusQueryHook = ({ userId, notificationId }: editBellNotificationStatusProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<BellNotification, unknown, BellNotification>((data: BellNotification) => {
+        return putAuth0(`/ANOT/Notifications/${notificationId}?`, {
+            pUserId: userId
+        }, data);
+    }, {
+        onSuccess: (data: BellNotification) => {
+            queryClient.setQueryData(
+                ['BELL_NOTIFICATION_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/editFieldsByBulkQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Bulk } from '../../interfaces';
+import { putAuth0 } from '../../services/ApiService';
+
+export const editFieldsByBulkQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Bulk, unknown, Bulk>((data: Bulk) => {
+        return putAuth0(`/AACP/Users/BulkUpdate?`, undefined, data);
+    }, {
+        onSuccess: (data: Bulk) => {
+            queryClient.setQueryData(
+                ['BULK_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/getBellNotificationsQuery.hook.ts

@@ -0,0 +1,28 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { BellNotification, ResponseList } from "../../interfaces";
+import { getAuth0 } from "../../services/ApiService";
+
+interface BellNotificationProps extends Omit<UseQueryOptions<ResponseList<"Notifications", BellNotification>>, "queryKey"> {
+    page?: number;
+    records?: number;
+    sortBy?: string;
+    sortDirection?: string;
+    query?: string;
+    language?: string;
+    userId: string;
+}
+
+export const getBellNotificationQueryHook = ({ page, records, sortBy, sortDirection, query, language, userId, ...options }: BellNotificationProps) => {
+    return useQuery(
+        ['BELL_NOTIFICATION_QUERY', page, records, sortBy, sortDirection, query, language, userId, options],
+        () => getAuth0<ResponseList<"Notifications", BellNotification>>(`/ANOT/Notifications/${userId}`, {
+            pPage: page || 1,
+            pRecords: records || 50,
+            pSortBy: sortBy || "Name",
+            pSortDirection: sortDirection || "asc",
+            pQuery: query || "",
+            pLanguage: language || "PT"
+        }),
+        options
+    );
+}

package/src/hooks/Others/getNotificationTitleQuery.hook.ts

@@ -0,0 +1,19 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { NotificationTitle, ResponseList } from "../../interfaces";
+import { getAuth0 } from "../../services/ApiService";
+
+interface NotificationTitleQueryHookQueryProps extends Omit<UseQueryOptions<ResponseList<"NotificationTypes", NotificationTitle>>, "queryKey"> {
+    page?: number;
+    records?: number;
+}
+
+export const getNotificationTitleQueryHook = ({ page, records, ...options }: NotificationTitleQueryHookQueryProps) => {
+    return useQuery(
+        ['NOTIFICATION_TITLE_QUERY', page, records],
+        () => getAuth0<ResponseList<"NotificationTypes", NotificationTitle>>('/APE/NotificationType', {
+            pPage: page || 1,
+            pRecords: records || 999999
+        }),
+        options
+    );
+}

package/src/hooks/Others/getRegulationQuery.hook.ts

@@ -0,0 +1,14 @@
+import { getAuth0 } from '../..';
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+
+interface GetRegulationQueryProps {
+    TermsAndConditionsURL: string;
+}
+
+export const getRegulationQueryHook = ({...options} : UseQueryOptions) => {
+    return useQuery(
+        ['REGULATION_QUERY'],
+        () => getAuth0<GetRegulationQueryProps>(`/AACP/Users/termsAndConditions`),
+        options
+    );
+};

package/src/hooks/Others/getUserEmailStatusQuery.hook.ts

@@ -0,0 +1,21 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { UserEmailStatus, ResponseList } from "../../interfaces";
+import { getAuth0 } from "../../services/ApiService";
+
+interface UserEmailStatusQueryProps extends Omit<UseQueryOptions<ResponseList<"UserStatus", UserEmailStatus>>, "queryKey"> {
+    page?: number;
+    records?: number;
+    tags?: string;
+}
+
+export const getUserEmailStatusQuery = ({ page, records, tags, ...options }: UserEmailStatusQueryProps) => {
+    return useQuery(
+        ['USER_EMAIL_STATUS', page, records, tags],
+        () => getAuth0<ResponseList<"UserStatus", UserEmailStatus>>('/APE/Validation', {
+            pPage: page || 1,
+            pRecords: records || 50,
+            pTerms: tags
+        }),
+        options
+    );
+}

package/src/hooks/Others/getWeeklyWorkloadQuery.hook.ts

@@ -0,0 +1,23 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Workload, ResponseList } from "../../interfaces";
+import { getAuth0 } from "../../services/ApiService";
+
+interface WeeklyWorkloadQueryHookQueryProps extends Omit<UseQueryOptions<ResponseList<"WeeklyWorkHours", Workload>>, "queryKey"> {
+    page?: number;
+    records?: number;
+    sortBy?: string;
+    sortDirection?: string;
+}
+
+export const getWeeklyWorkloadQueryHook = ({ page, records, sortBy, sortDirection, ...options }: WeeklyWorkloadQueryHookQueryProps) => {
+    return useQuery(
+        ['WORKLOAD_QUERY', page, records, sortBy, sortDirection],
+        () => getAuth0<ResponseList<"WeeklyWorkHours", Workload>>('/AACP/WeeklyWorkHours', {
+            pPage: page || 1,
+            pRecords: records || 195,
+            pSortBy: 'WorkHours',
+            pSortDirection: sortDirection || 'asc',
+        }),
+        options
+    );
+}

package/src/hooks/Others/oneSignalUserQuery.hook.ts

@@ -0,0 +1,14 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { postAuth0 } from '../../services/ApiService';
+
+export const oneSignalUserQuery = () => {
+    const queryClient = useQueryClient();
+    return useMutation<any, unknown, any>((data: any) => {
+        return postAuth0('/ANOT/Users/Register', undefined, data);
+    }, {
+        onSuccess: (data: any) => {
+            queryClient.setQueryData(
+                ['ONESIGNAL_USER_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/postCheckoutsMutateQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { Checkout } from '../../interfaces';
+import { post } from '../../services/ApiService';
+
+export const postCheckoutsMutateQueryHook = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Checkout, unknown, Checkout>((data: Checkout) => {
+        return post('/APRE/Checkouts', data);
+    }, {
+        onSuccess: (data: Checkout) => {
+            queryClient.setQueryData(
+                ['CHECKOUT'], data);
+        },
+    });
+}

package/src/hooks/Others/postUserAuthenticationQuery.hook.ts

@@ -0,0 +1,19 @@
+import { postWithParameters, UserAuthentication } from '../..';
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+
+export interface UserAuthenticationQueryProps extends UseQueryOptions<UserAuthentication> {
+    storeCode: string;
+}
+
+export const postUserAuthenticationHook = ({ storeCode }: UserAuthenticationQueryProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<UserAuthenticationQueryProps, unknown, UserAuthentication>(() => {
+        return postWithParameters(`/AACP/Authentication/User/Login?`, {
+            pStoreId: storeCode
+        });
+    }, {
+        onSuccess: (data: UserAuthenticationQueryProps) => {
+            queryClient.setQueryData(['POST_USER_AUTHENTICATION_QUERY'], data);
+        },
+    });
+};

package/src/hooks/Others/postVerifyImageQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { VerifyImage } from '../../interfaces';
+import { postAuth0 } from '../../services/ApiService';
+
+export const postVerifyImageQueryHook = (bodyType?: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<VerifyImage, unknown, VerifyImage>((data: VerifyImage | any) => {
+        return postAuth0('/AACP/FaceAuthentication/verify', undefined, data, bodyType);
+    }, {
+        onSuccess: (data: VerifyImage) => {
+            queryClient.setQueryData(
+                ['VERIFY_IMAGE'], data);
+        },
+    });
+}

package/src/hooks/Others/unblockUserQuery.hook.ts

@@ -0,0 +1,14 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { postAuth0 } from "../../services/ApiService";
+
+export const unblockUserQueryHook = (userId: string) => {
+    const queryClient = useQueryClient();
+    return useMutation<boolean, unknown>(() => {
+        return postAuth0(`/AACP/Users/${userId}/unblock`, undefined);
+    }, {
+        onSuccess: (data) => {
+            queryClient.setQueryData(
+                ['UNBLOCK_USER_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Others/useApplicationDataQuery.hook.ts

@@ -0,0 +1,10 @@
+import { useQuery } from "@tanstack/react-query";
+import { ApplicationsByCategory, ResponseList } from "../../interfaces";
+import { getAuth0 } from "../../services/ApiService";
+
+export const useApplicationDataQueryHook = () => {
+    return useQuery(
+        ['APPLICATIONS_QUERY'],
+            () => getAuth0<ResponseList<"Categories", ApplicationsByCategory>>('/AACP/Applications/groupByCategory')
+    );
+}

package/src/hooks/Others/useContractStatesQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { ContractStates, ResponseList } from "../../interfaces";
+import { getAuth0 } from "../../services/ApiService";
+
+interface ContractStatesQueryProps extends Omit<UseQueryOptions<ResponseList<"ContractStates", ContractStates>>, "queryKey"> {
+    records: string;
+}
+
+export const useContractStatesQuery = ({ records, ...options }: ContractStatesQueryProps) => {
+    return useQuery(
+        ['CONTRACTSTATES_QUERY', records],
+        () => getAuth0<ResponseList<"ContractStates", ContractStates>>(`/AACP/ContractStates`, { pPage: 1, pRecords: records || 195 }),
+        options
+    );
+}

package/src/hooks/Others/useCountriesQuery.hook.ts

@@ -0,0 +1,15 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Countries, ResponseList } from "../../interfaces";
+import { get } from "../../services";
+
+interface CountriesQueryProps extends Omit<UseQueryOptions<ResponseList<"Countries", Countries>>, "queryKey"> {
+    records: string;
+}
+
+export const useCountriesQuery = ({ records, ...options }: CountriesQueryProps) => {
+    return useQuery(
+        ['COUNTRIES_QUERY', records],
+        () => get<ResponseList<"Countries", Countries>>(`/Franchise/Countries`, { pPage: 1, pRecords: records || 195 }),
+        options
+    );
+}

package/src/hooks/Others/useCreateNotification.hook.ts

@@ -0,0 +1,24 @@
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+import { CreateNotification } from "../../interfaces";
+import { postAuth0 } from "../../services/ApiService";
+
+export interface CreateNotificationInterf extends UseQueryOptions<CreateNotification> {
+    evaluationCycleId?: string;
+    userId?: string;
+}
+
+export const useCreateNotificationHook = ({ evaluationCycleId, userId }: CreateNotificationInterf) => {
+    const queryClient = useQueryClient();
+    return useMutation<CreateNotification, unknown, CreateNotification>((data: CreateNotification) => {
+        return postAuth0(`/APE/Notification/CreateNotification?`, {
+            pEvaluationCycleId: evaluationCycleId,
+            pUserId: userId,
+        },
+            data
+        );
+    }, {
+        onSuccess: (data: CreateNotification) => {
+            queryClient.setQueryData(['CREATE_NOTIFICATION_QUERY'], data);
+        },
+    });
+};

package/src/hooks/Others/useCustomersQuery.hook.ts

@@ -0,0 +1,40 @@
+import { get, Customer, ResponseList } from '../../';
+import { useInfiniteQuery, useQuery, UseQueryOptions } from '@tanstack/react-query';
+
+export interface CustomersQuery extends UseQueryOptions<ResponseList<"Customers", Customer>> {
+    page?: number;
+    records?: number;
+    email?: string;
+    code?: string;
+}
+
+export const useCustomersQueryHook = ({ page, records, email, code, ...options }: CustomersQuery) => {
+    return useQuery<ResponseList<"Customers", Customer>>(['Customers', page, records, email, code], () =>
+        get('/CRMCustomers', {
+            pPage: page || 1,
+            pRecords: records,
+            pEmail: email,
+            pCode: code,
+            pSource: 'Custom'
+        }), options);
+};
+
+export const useCustomersInfiniteQueryHook = ({ email, code }: Omit<CustomersQuery, 'page' | 'records'> = {}) => {
+    const infiniteQuery = useInfiniteQuery(['Customers_Infinite', email, code], ({ pageParam = 1 }) =>
+        get<ResponseList<"Customers", Customer>>('/CRMCustomers', {
+            pPage: pageParam, 
+            pRecords: 50,
+            pEmail: email,
+            pCode: code,
+            pSource: 'Custom',
+        }));
+
+    const pagesMulti = infiniteQuery.data?.pages?.map((page) => (page.Customers as Customer[]) || []) || [];
+    const allDataGrouped = ([] as Customer[]).concat(...pagesMulti);
+
+    return {
+        ...infiniteQuery,
+        count: infiniteQuery.data?.pages?.[0].Count || 0,
+        data: allDataGrouped,
+    }
+};

package/src/hooks/Others/useJobTitlesQuery.hook.ts

@@ -0,0 +1,17 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { JobTitles, ResponseList } from "../../interfaces";
+import { getAuth0 } from "../../services";
+
+interface JobTitlesQueryProps extends Omit<UseQueryOptions<ResponseList<"JobTitles", JobTitles>>, "queryKey"> {
+    records: string;
+    sortBy: string;
+    sortDirection: string;
+}
+
+export const useJobTitlesQuery = ({ records, sortBy, sortDirection, ...options }: JobTitlesQueryProps) => {
+    return useQuery(
+        ['JOBTITLES_QUERY', records, sortBy, sortDirection],
+        () => getAuth0<ResponseList<"JobTitles", JobTitles>>(`/AACP/JobTitles`, { pPage: 1, pRecords: records || 195, pSortBy: sortBy || "Rank", pSortDirection: sortDirection || "asc" }),
+        options
+    );
+}

package/src/hooks/Others/useRegulationQuery.hook.ts

@@ -0,0 +1,24 @@
+import { putAuth0 } from '../..';
+import { UseQueryOptions, useMutation, useQueryClient } from '@tanstack/react-query';
+
+interface TermsAndConditionsURLProps {
+    TermsAndConditionsURL: string;
+
+}
+
+export interface RegulationQueryProps extends UseQueryOptions<TermsAndConditionsURLProps> {
+    userId: string;
+}
+
+export const useRegulationQueryHook = ({ userId }: RegulationQueryProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<RegulationQueryProps, unknown, string>(() => {
+        return putAuth0(`/AACP/Users/termsAndConditions?`, {
+            pUserId: userId
+        });
+    }, {
+        onSuccess: (data: RegulationQueryProps) => {
+            queryClient.setQueryData(['PUT_REGULATION_QUERY'], data);
+        },
+    });
+};

package/src/hooks/Others/useTermNotificationQuery.hook.ts

@@ -0,0 +1,11 @@
+import { useQuery } from "@tanstack/react-query";
+import { TermNotification } from "../../interfaces";
+import { getAuth0 } from "../../services/ApiService";
+
+export const useTermNotificationQueryHook = () => {
+    return useQuery(
+        ['TERM_NOTIFICATION_QUERY'],
+        () => getAuth0<TermNotification[]>(`/APE/TermNotification`),
+    );
+}
+

package/src/hooks/Questionnaire/get/useQuestionnaireIdQuery.hook.ts

@@ -0,0 +1,13 @@
+import { useQuery } from "@tanstack/react-query";
+import { Questionnaire } from "../../../interfaces";
+import { getAuth0 } from "../../../services/ApiService";
+
+export const useQuestionnaireIdQueryHook = (surveyId: string) => {
+    return useQuery(
+        ['QUESTIONNAIRE_ID_QUERY', surveyId],
+        () => getAuth0<Questionnaire>(`/APE/Questionnaire/${surveyId}`),
+        {
+            enabled: !!(surveyId),
+        },
+    );
+}

package/src/hooks/Questionnaire/get/useQuestionnaireQuery.hook.ts

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