@omniumretail/shared-resources 0.3.85 → 0.3.86

package/src/hooks/OSUA/get/documentos/getGngDocumentos.hook.ts

@@ -0,0 +1,28 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { get } from "../../../../services/ApiService";
+import { DocumentGng, ResponseList } from "../../../../interfaces";
+
+interface GetGNGDocumentosProps
+  extends UseQueryOptions<ResponseList<"Documents", DocumentGng>> {
+  page?: number;
+  records?: number;
+  query?: string;
+}
+
+export const getGngDocumentos = ({
+  page,
+  records,
+  query,
+  ...options
+}: GetGNGDocumentosProps) => {
+  return useQuery(
+    ["GNG_DOCUMENTOS", page, records, query],
+    () =>
+      get<ResponseList<"Documents", DocumentGng>>("/GNG/Document/Documents", {
+        pPage: page || 1,
+        pRecords: records || 50,
+        pQuery: query,
+      }),
+    options
+  );
+};

package/src/hooks/OSUA/get/documentos/getSitooDocumentos.hook.ts

@@ -0,0 +1,21 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { get } from "../../../../services/ApiService";
+import { ResponseList, DocumentSitoo } from '../../../../interfaces';
+
+interface GetSitooDocumentosProps extends UseQueryOptions<ResponseList<"Items", DocumentSitoo>> {
+    fields?: string;
+    externalid?: string;
+
+}
+
+export const getSitooDocumentos = ({ fields, externalid, ...options}: GetSitooDocumentosProps) => {
+    return useQuery(
+        ['SITOO_DOCUMENTOS', fields, externalid],
+        () => get<ResponseList<"Items", DocumentSitoo>>('/Sitoo/Orders', {
+            pFields: fields || "externalid,orderid",
+            pExternalid: externalid ,
+       
+        }),
+        options
+    );
+}

package/src/hooks/OSUA/get/eventos/getSitooErrorEvents.hook.ts

@@ -0,0 +1,30 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { get } from "../../../../services/ApiService";
+import { ResponseList, DocumentErrorEvent} from '../../../../interfaces';
+
+
+interface GetSitooErrorEventsProps extends UseQueryOptions<ResponseList<"Events", DocumentErrorEvent>> {
+    page?: number;
+    records?: number;
+    sortBy?: string;
+    sortDirection?: string;
+}
+
+export const getSitooErrorEvents = ({
+    page,
+    records,
+    sortBy,
+    sortDirection,
+    ...options
+}: GetSitooErrorEventsProps) => {
+    return useQuery(
+        ['SITOO_ERROR_EVENTS', page, records, sortBy, sortDirection],
+        () => get<ResponseList<"Events", DocumentErrorEvent>>('/Sitoo/Document/Events/Error', {
+            pPage: page,
+            pRecords: records,
+            pSortBy: sortBy || "EventDate",
+            pSortDirection: sortDirection || "desc",
+        }),
+        options
+    );
+};

package/src/hooks/OSUA/get/faqs/getFaqsQuery.hook.ts

@@ -0,0 +1,33 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import {  getAuth0 } from "../../../../services/ApiService";
+import {ResponseList, Section } from "../../../../interfaces"; // Assuming Section is in the interfaces
+
+interface GetSectionProps extends UseQueryOptions<ResponseList< "Sections", Section>> {
+  page?: number;
+  records?: number;
+  sortBy?: string;
+  sortDirection?: string;
+  terms?: string;
+}
+
+export const getFaqsQuery = ({
+  page,
+  records,
+  sortBy,
+  sortDirection,
+  terms,
+  ...options
+}: GetSectionProps) => {
+  return useQuery(
+    ["FAQS_DATA", page, records, sortBy, sortDirection, terms],
+    () =>
+      getAuth0<ResponseList< "Sections", Section>>("/OSUA/Pages", {
+        pPage: page || 1,
+        pRecords: records || 10,
+        pSortBy: sortBy || "Title",
+        pSortDirection: sortDirection || "asc",
+        pTerms: terms,
+      }),
+    options
+  );
+};

package/src/hooks/OSUA/get/orders/getOrderDocuments.hook.ts

@@ -0,0 +1,21 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { get } from '../../../../services/ApiService';
+import { DocumentGng , ResponseList} from '../../../../interfaces';
+
+interface GetGNGDocumentosOrderProps extends UseQueryOptions<ResponseList<"Documents", DocumentGng>> {
+    page?: number;
+    records?: number;
+    query?: string;
+}
+
+export const getOrderDocuments = ({ page, records , query, ...options }: GetGNGDocumentosOrderProps) => {
+  return useQuery(
+    ['GNG_DOCUMENTOS', page, records, query],
+    () => get<ResponseList<"Documents", DocumentGng>>('/GNG/Document/Documents/In', {
+        pPage: page || 1,
+        pRecords: records || 50,
+        pQuery: query,
+    }),
+    options
+  );
+}

package/src/hooks/OSUA/get/queue/getQueues.hook.ts

@@ -0,0 +1,15 @@
+import { useQuery } from "@tanstack/react-query";
+import { getAuth0 } from "../../../../services/ApiService";
+import { ResponseList, Queues } from "../../../../interfaces";
+
+
+export const getQueues = () => {
+  return useQuery(
+    ['OSUA_QUEUES'],
+    () => getAuth0<ResponseList<"QueueConfigurations", Queues>>('/OSUA/Queues'),
+    {
+      enabled: true, 
+      retry: 1 
+    }
+  );
+};

package/src/hooks/OSUA/get/queue/getQueuesMessages.hook.ts

@@ -0,0 +1,28 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { getAuth0 } from "../../../../services/ApiService";
+import { ResponseList, QueuesMessages} from '../../../../interfaces';
+
+
+
+interface GetQueuesMessagesProps extends UseQueryOptions<ResponseList<"Messages", QueuesMessages>> {
+    id?: string;
+    page?: number;
+    records?: number;
+}
+
+export const getQueuesMessages = ({
+    id,
+    page,
+    records,
+    ...options
+}: GetQueuesMessagesProps) => {
+    return useQuery(
+        ['OSUA_QUEUES_MESSAGES', id,  page, records],
+        () => getAuth0<ResponseList<"Messages", QueuesMessages>>(`/OSUA/Queues/Messages`, {
+            pPage: page,
+            pRecords: records,
+            pQueueName: id
+        }),
+        options
+    );
+};

package/src/hooks/OSUA/get/vouchers/getGngVoucher.hook.ts

@@ -0,0 +1,21 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { get } from "../../../../services/ApiService";
+import { ResponseList, GiftCards } from '../../../../interfaces';
+
+interface GetGNGVoucherProps extends UseQueryOptions<ResponseList<"GiftCards", GiftCards>> {
+    page?: number;
+    records?: number;
+    query?: string;
+}
+
+export const getGNGVoucher = ({ page, records, query, ...options}: GetGNGVoucherProps) => {
+    return useQuery(
+        ['GNG_VOUCHER', page, records, query],
+        () => get<ResponseList<"GiftCards", GiftCards>>('/GNG/Document/GiftCards', {
+            pPage: page || 1,
+            pRecords: records || 50,
+            pQuery: query 
+        }),
+        options
+    );
+}

package/src/hooks/OSUA/get/vouchers/getOsuaVouchersQuery.hook.ts

@@ -0,0 +1,27 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { ResponseList, GiftCards } from '../../../../interfaces';
+import { getAuth0 } from '../../../../services/ApiService';
+
+interface GetOsuaVoucherProps extends UseQueryOptions<ResponseList<"Vouchers", GiftCards>> {
+    page: number;
+    records: number;
+    sortBy: string;
+    sortDirection: string;
+    terms?: string;
+    query?: string;
+}
+
+export const getOsuaVoucher = ({ page, records, sortBy, sortDirection, terms, query, ...options }: GetOsuaVoucherProps) => {
+    return useQuery(
+        ['OSUA_VOUCHER', page, records, sortBy, sortDirection, terms, query, options],
+        () => getAuth0<ResponseList<"Vouchers", GiftCards>>('/OSUA/Vouchers', {
+            pPage: page || 1,
+            pRecords: records || 50,
+            pSortBy: sortBy || "Name",
+            pSortDirection: sortDirection || "asc",
+            pTerms: terms || "",
+            pQuery: query || ""
+        }),
+        options
+    );
+}

package/src/hooks/OSUA/get/vouchers/getSalesNumberOsua.hook.ts

@@ -0,0 +1,26 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { getAuth0 } from "../../../../services/ApiService";
+
+interface OsuaVoucher { Id: string;}
+interface OsuaError { Code: string; Message: string;}
+
+interface GetSalesNumberOsuaProps extends UseQueryOptions<OsuaVoucher, OsuaError> {
+    pGiftCardNumber?: string;
+}
+
+
+export const getSalesNumberOsua = ({ pGiftCardNumber, ...options }: GetSalesNumberOsuaProps) => {
+    return useQuery<OsuaVoucher, OsuaError>(
+        ['SALES_NUMBER_OSUA_VOUCHERS', pGiftCardNumber],
+        () =>
+        
+        getAuth0<OsuaVoucher>('/GNG/Document/Documents/findByGiftCardNumber', {
+            pGiftCardNumber: pGiftCardNumber,
+        }),
+        {
+        ...options,
+        retry: false,
+        }
+    );
+};
+  

package/src/hooks/OSUA/get/vouchers/getSitooVouchers.hook.ts

@@ -0,0 +1,22 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { getBasic } from "../../../../services/ApiService";
+import { SitooVoucher } from '../../../../interfaces';
+
+interface GetSitooVouchersProps extends UseQueryOptions<SitooVoucher>{
+    id?: string;
+}
+
+export const getSitooVouchers = ({ id, ...options }: GetSitooVouchersProps) => {
+    return useQuery(
+        ['SITOO_VOUCHERS', id],
+
+        () => getBasic<SitooVoucher>(`/GNG/GiftCard/SPIGiftCard/giftcards/${id}.json`),
+        {
+            ...options,
+            retry: false,
+        
+        }
+
+    );
+}
+

package/src/hooks/OSUA/get/vouchers/getVoucherIntegrationRequestStatus.hook.ts

@@ -0,0 +1,23 @@
+import { useQuery, UseQueryOptions } from '@tanstack/react-query';
+import { get } from "../../../../services/ApiService";
+import { IntegrationRequestStatus } from '../../../../interfaces';
+
+interface GetVoucherIntegrationRequestStatusProps extends UseQueryOptions< IntegrationRequestStatus> {
+    pIntegrationType?: string;
+    pSourcePlatformId?: string;
+}
+
+export const getVoucherIntegrationRequestStatus = ({ pIntegrationType, pSourcePlatformId, ...options}: GetVoucherIntegrationRequestStatusProps) => {
+    return useQuery(
+        ['INTEGRATION_REQUEST_STATUS', pIntegrationType, pSourcePlatformId],
+        () => get<IntegrationRequestStatus>('/Document/IntegrationRequests/latestIntegration', {
+            pIntegrationType: pIntegrationType ,
+            pSourcePlatformId: pSourcePlatformId 
+        }),
+        {
+            ...options,
+            retry: false,
+        
+        }
+    );
+}

package/src/hooks/OSUA/mutate/activateOsuaVoucherQuery.hook.ts

@@ -0,0 +1,24 @@
+
+
+import { useMutation, useQueryClient, UseQueryOptions } from '@tanstack/react-query';
+import { IntegrationRequestStatus } from '../../../interfaces';
+import { putAuth0 } from '../../../services';
+
+interface ActivateOsuaVoucherProps extends UseQueryOptions<IntegrationRequestStatus> {
+    customerId: string;
+    reedemId: string;
+}
+
+export const activateOsuaVoucher = ({ customerId, reedemId }: ActivateOsuaVoucherProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<{ Success: boolean }, unknown, void>(() => {
+        return putAuth0('/OSUA/Vouchers/Activate?', {
+            pCustomerId: customerId,
+            pRedeemId: reedemId
+        });
+    }, {
+        onSuccess: (data: { Success: boolean }) => {
+            queryClient.setQueryData(['ACTIVATE_OSUA_VOUCHER'], data);
+        },
+    });
+}

package/src/hooks/OSUA/mutate/postCreateIntegrationRequest.hook.ts

@@ -0,0 +1,28 @@
+
+
+import { useMutation, useQueryClient, UseQueryOptions } from '@tanstack/react-query';
+import { IntegrationRequestStatus } from '../../../interfaces';
+import { postWithParameters } from "../../../services/ApiService";
+
+interface PostCreateIntegrationRequestProps extends UseQueryOptions<IntegrationRequestStatus> {
+    integrationType?: string;
+    sourcePlatformId?: string;
+    destinations?: string;
+    query?: string;
+}
+
+export const postCreateIntegrationRequest = ({integrationType, sourcePlatformId, destinations, query}: PostCreateIntegrationRequestProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<IntegrationRequestStatus, unknown, IntegrationRequestStatus>(() => {
+        return postWithParameters('/Document/IntegrationRequests?', {
+            pIntegrationType: integrationType ,
+            pSourcePlatformId: sourcePlatformId ,
+            pDestinations: destinations,
+            pQuery: query,
+        });
+    }, {
+        onSuccess: (data: IntegrationRequestStatus) => {
+            queryClient.setQueryData(['CREATE_INTEGRATION_REQUEST'], data);
+        },
+    });
+}

package/src/hooks/OSUA/mutate/postEventsRep.hook.ts

@@ -0,0 +1,16 @@
+import { useQueryClient, useMutation } from "@tanstack/react-query";
+import { post } from "../../../services/ApiService";
+
+export const postEventsRep = () => {
+  const queryClient = useQueryClient();
+  return useMutation<string, unknown, void>(
+    () => {
+      return post("/Sitoo/Document/EventsReprocessing");
+    },
+    {
+      onSuccess: (data: string) => {
+        queryClient.setQueryData(["POST_EVENTS_REPROCESSING"], data);
+      },
+    }
+  );
+};

package/src/hooks/OSUA/mutate/postQueuesMessages.hook.ts

@@ -0,0 +1,21 @@
+import { UseQueryOptions, useMutation, useQueryClient } from "@tanstack/react-query";
+import { QueuesMessages } from "../../../interfaces";
+import { postAuth0 } from "../../../services/ApiService";
+
+export interface PostQueesMessages extends UseQueryOptions<QueuesMessages> {
+    id: string;
+}
+
+export const postQueesMessages = ({ id }: PostQueesMessages) => {
+    const queryClient = useQueryClient();
+    return useMutation<QueuesMessages, unknown, QueuesMessages>((data: QueuesMessages) => {
+        return postAuth0('/OSUA/Queues/Messages?',{
+            pQueueName: id,
+        }, data);
+    }, {
+        onSuccess: (data: QueuesMessages) => {
+            queryClient.setQueryData(
+                ['POST_OSUA_QUEUES'], data);
+        },
+    });
+}

package/src/hooks/OSUA/mutate/postVoucher.hook.ts

@@ -0,0 +1,16 @@
+import {  useQueryClient, useMutation } from '@tanstack/react-query';
+import { CreateVoucher } from "../../../interfaces";
+import { postAuth0 } from "../../../services/ApiService"; 
+
+
+export const postVoucherOsua = () => { 
+    const queryClient = useQueryClient();
+    return useMutation<CreateVoucher , unknown, CreateVoucher>((data: CreateVoucher ) => {
+        return postAuth0('/OSUA/GiftCards', undefined, data);
+    }, {
+        onSuccess: (data: CreateVoucher ) => {
+            queryClient.setQueryData(
+                ['POST_VOUCHER_OSUA'], data);
+        },
+    });
+}

package/src/hooks/OSUA/mutate/putBalanceVouchers.hook.ts

@@ -0,0 +1,25 @@
+import { useMutation, useQueryClient, UseQueryOptions } from "@tanstack/react-query";
+import {  putAuth0 } from "../../../services/ApiService";
+import { BalanceVouchers } from "../../../interfaces";
+
+export interface BalanceVouchersQueryProps extends UseQueryOptions<BalanceVouchers> {
+    giftCardNumber: string;
+}
+
+export const putBalanceVouchers = ({ giftCardNumber }: BalanceVouchersQueryProps) => {
+  const queryClient = useQueryClient();
+
+  return useMutation<BalanceVouchers, unknown, BalanceVouchers>((data: BalanceVouchers) => {
+      return  putAuth0(`/OSUA/GiftCards?`, {
+        pGiftCardNumber: giftCardNumber,
+      },
+        data
+    );
+    },
+    {
+      onSuccess: (data: BalanceVouchers) => {
+        queryClient.setQueryData(["UPDATE_VOUCHERS_QUERY"], data);
+      }
+    }
+  );
+};

package/src/hooks/OSUA/mutate/useSetIntegrationToFinished.hook.ts

@@ -0,0 +1,21 @@
+import {  useMutation, useQueryClient } from "@tanstack/react-query";
+import {  putWithParameters } from "../../../services/ApiService";
+import { IntegrationData } from "../../../interfaces";
+
+
+export const useSetIntegrationToFinished = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<IntegrationData, unknown, IntegrationData>(
+    (data: IntegrationData) => {
+      return  putWithParameters(`/MIMO/IntegrationData/SetToFinished?`, {
+        pName: data.Name,
+      }, data);
+    },
+    {
+      onSuccess: (data: IntegrationData) => {
+        queryClient.setQueryData(["INTEGRATION_DATA_QUERY"], data);
+      }
+    }
+  );
+};

package/src/hooks/Orch/get/getAuth0ConfigQuery.hook.ts

@@ -0,0 +1,11 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Auth0Config } from "../../../interfaces";
+import { get } from "../../../services/ApiService";
+
+export const getAuth0ConfigQueryHook = ({...options} : UseQueryOptions) => {
+    return useQuery(
+        ['AUTH0_CONFIG_QUERY', options],
+        () => get<Auth0Config>(`/AACP/Authentication/Configuration`),
+        options
+    );
+}

package/src/hooks/Orch/get/getInstanceByIdQuery.hook.ts

@@ -0,0 +1,14 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Instances } from "../../../interfaces";
+import { getAuth0 } from "../../../services/ApiService";
+
+export const getInstanceByIdQueryHook = (instanceId: string, { ...options }: UseQueryOptions<Instances>, userDetails?: boolean) => {
+    return useQuery(
+        ['INSTANCE_BY_ID_QUERY', instanceId, options, userDetails],
+        () => getAuth0<Instances>(`/ORQ/Instances/${instanceId}`, {
+            pIncludeUserDetails: userDetails || true
+        }),
+        options
+    );
+}
+ 

package/src/hooks/Orch/get/getInstancesQuery.hook.ts

@@ -0,0 +1,27 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Instances, ResponseList } from "../../../interfaces";
+import { getAuth0 } from "../../../services/ApiService";
+
+interface InstancesProps extends Omit<UseQueryOptions<ResponseList<"Instances", Instances>>, "queryKey"> {
+    page: number;
+    records: number;
+    sortBy: string;
+    sortDirection: string;
+    terms?: string;
+    query?: string;
+}
+
+export const getInstancesQueryHook = ({ page, records, sortBy, sortDirection, terms, query, ...options }: InstancesProps) => {
+    return useQuery(
+        ['INSTANCES_QUERY', page, records, sortBy, sortDirection, terms, query, options],
+        () => getAuth0<ResponseList<"Instances", Instances>>(`/ORQ/Instances`, {
+            pPage: page,
+            pRecords: records,
+            pSortBy: sortBy,
+            pSortDirection: sortDirection,
+            pTerms: terms || "",
+            pQuery: query || ""
+        }),
+        options
+    );
+}

package/src/hooks/Orch/get/getMacrosInstancesQuery.hook.ts

@@ -0,0 +1,19 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { MacroInstance } from "../../../interfaces";
+import { getAuth0 } from "../../../services/ApiService";
+
+interface MacrosInstancesProps extends Omit<UseQueryOptions<MacroInstance>, "queryKey"> {
+    costumerId?: string;
+    type?: string;
+}
+
+export const getMacrosInstancesQueryHook = ({ costumerId, type, ...options }: MacrosInstancesProps) => {
+    return useQuery(
+        ['MACROS_INSTANCES_QUERY', costumerId, type, options],
+        () => getAuth0<MacroInstance>(`/ORQ/Instances/Last`, {
+            pCustomerId: costumerId || "GNG",
+            pType: type || "Product"
+        }),
+        options
+    );
+}

package/src/hooks/Orch/get/getMacrosQuery.hook.ts

@@ -0,0 +1,27 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Macros, ResponseList } from "../../../interfaces";
+import { getAuth0 } from "../../../services/ApiService";
+
+interface MacrosProps extends Omit<UseQueryOptions<ResponseList<"Macros", Macros>>, "queryKey"> {
+    page: number;
+    records: number;
+    sortBy: string;
+    sortDirection: string;
+    terms?: string;
+    query?: string;
+}
+
+export const getMacrosQueryHook = ({ page, records, sortBy, sortDirection, terms, query, ...options }: MacrosProps) => {
+    return useQuery(
+        ['MACROS_QUERY', page, records, sortBy, sortDirection, terms, query, options],
+        () => getAuth0<ResponseList<"Macros", Macros>>(`/ORQ/Macros`, {
+            pPage: page,
+            pRecords: records,
+            pSortBy: sortBy,
+            pSortDirection: sortDirection,
+            pTerms: terms || "",
+            pQuery: query || ""
+        }),
+        options
+    );
+}

package/src/hooks/Orch/get/getMacrosUserQuery.hook.ts

@@ -0,0 +1,11 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { Instances } from "../../../interfaces";
+import { getAuth0 } from "../../../services/ApiService";
+
+export const getMacrosUserQueryHook = (instanceId: string, { ...options }: UseQueryOptions<Instances>) => {
+    return useQuery(
+        ['MACROS_USER_QUERY', instanceId, options],
+        () => getAuth0<Instances>(`/ORQ/Instances/${instanceId}/User`, undefined),
+        options
+    );
+}

package/src/hooks/Orch/get/getMonitoringComponents.hook.ts

@@ -0,0 +1,29 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { MonitoringComponent, ResponseList } from "../../../interfaces";
+import { getAuth0 } from "../../../services/ApiService";
+
+interface MonitoringComponentProps extends Omit<UseQueryOptions<ResponseList<"Components", MonitoringComponent>>, "queryKey"> {
+    page: number;
+    records: number;
+    sortBy: string;
+    sortDirection: string;
+    terms?: string;
+    query?: string;
+    getStatus: boolean;
+}
+
+export const getMonitoringComponentQueryHook = ({ page, records, sortBy, sortDirection, terms, query, getStatus, ...options }: MonitoringComponentProps) => {
+    return useQuery(
+        ['MONITORINGCOMPONENTS_QUERY', page, records, sortBy, sortDirection, terms, query, getStatus, options],
+        () => getAuth0<ResponseList<"Components", MonitoringComponent>>(`/ORQ/Monitoring`, {
+            pPage: page,
+            pRecords: records,
+            pSortBy: sortBy,
+            pSortDirection: sortDirection,
+            pTerms: terms || "",
+            pQuery: query || "",
+            pGetStatus : getStatus
+        }),
+        options
+    );
+}

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

@@ -0,0 +1,14 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { postAuth0 } from '../../../services/ApiService';
+
+export const reprocessingInstanceQueryHook = (instanceId: string[]) => {
+    const queryClient = useQueryClient();
+    return useMutation<any, unknown, string[]>(() => {
+        return postAuth0(`/ORQ/Instances/Reprocessing?`, undefined, instanceId);
+    }, {
+        onSuccess: (data) => {
+            queryClient.setQueryData(
+                ['REPROCESSING_INSTANCE_QUERY'], data);
+        },
+    });
+}

package/src/hooks/Orch/others/runMacrosQuery.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 RunMacrosProps {
+    macroId: string;
+    filter: string;
+}
+
+export const runMacrosQueryHook = ({ macroId, filter }: RunMacrosProps) => {
+    const queryClient = useQueryClient();
+    return useMutation<TransferPickProducts, unknown>(() => {
+        return postAuth0(`/ORQ/Macros/Run?`, {
+            pMacroId: macroId,
+            pQuery: filter
+        });
+    }, {
+        onSuccess: (data) => {
+            queryClient.setQueryData(
+                ['RUN_MACROS_QUERY'], data);
+        },
+    });
+}