@zauru-sdk/services 1.0.5 → 1.0.7

package/dist/zauru/zauru-forms.server.js

@@ -0,0 +1,343 @@
+import { arrayToObject, convertToFormData, handlePossibleAxiosErrors, } from "@zauru-sdk/common";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getFormByNameStringQuery, getFormSubmissionByIdStringQuery, getFormsByDocumentTypeStringQuery, getFormsStringQuery, getInvoiceFormSubmissionsByAgencyIdStringQuery, getInvoiceFormSubmissionsByInvoiceIdStringQuery, getLastInvoiceFormSubmissionStringQuery, getMyCaseFormSubmissionsStringQuery, } from "@zauru-sdk/graphql";
+import httpZauru from "./httpZauru.server.js";
+/**
+ * getForms
+ */
+export async function getForms(session) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getFormsStringQuery,
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        const registers = response?.data?.data?.settings_forms;
+        return registers;
+    });
+}
+/**
+ * getFormByName
+ */
+export async function getFormByName(session, name) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getFormByNameStringQuery,
+            variables: {
+                name,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        if (!response?.data?.data?.settings_forms[0]) {
+            throw new Error(`No se encontró ningún formulario con el nombre: ${name} asociado`);
+        }
+        const register = response?.data?.data?.settings_forms[0];
+        return register;
+    });
+}
+/**
+ * getFormsByDocumentType
+ */
+export async function getFormsByDocumentType(session, document_type, filters = {}) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getFormsByDocumentTypeStringQuery(filters),
+            variables: {
+                document_type,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        const registers = response?.data?.data?.settings_forms;
+        // Filtrar los registros para obtener sólo los de la versión más alta.
+        const groupedByVersion = registers.reduce((acc, record) => {
+            const zid = record.zid;
+            if (!acc[zid]) {
+                acc[zid] = record;
+            }
+            return acc;
+        }, {});
+        const latestVersionRecords = Object.values(groupedByVersion).reverse();
+        return latestVersionRecords;
+    });
+}
+/**
+ * getFormSubmissionById
+ */
+export async function getFormSubmissionById(headersZauru, session, id, config = { withFiles: false }) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getFormSubmissionByIdStringQuery,
+            variables: {
+                formId: id,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        if (!response?.data?.data?.settings_form_submissions.length) {
+            throw new Error("No se encontró el form submission indicado.");
+        }
+        const register = response?.data?.data?.settings_form_submissions[0];
+        if (config.withFiles) {
+            const responseZauru = await httpZauru.get(`/settings/forms/form_submissions/${id}.json`, {
+                headers: headersZauru,
+            });
+            register.settings_form_submission_values =
+                register.settings_form_submission_values.map((x) => {
+                    if (x.settings_form_field.field_type === "image" ||
+                        x.settings_form_field.field_type === "file" ||
+                        x.settings_form_field.field_type === "pdf") {
+                        x.value = responseZauru.data[x.settings_form_field.print_var_name]
+                            ?.toString()
+                            .replace(/\\u0026/g, "&");
+                    }
+                    return x;
+                });
+        }
+        return register;
+    });
+}
+/**
+ * getInvoiceFormSubmissionsByAgencyId
+ */
+export async function getInvoiceFormSubmissionsByAgencyId(session, agency_id, filters) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const queryBuilded = getInvoiceFormSubmissionsByAgencyIdStringQuery({
+            seller_id: filters?.seller_id,
+            payee_id_number_search: filters?.payee_id_number_search,
+            //some_field_value: filters?.some_field_value, //Este filtro ahora lo hago abajo, con código, porque al hacerlo así antes,
+            //no funcionaba para cuando se cambiaba un campo, por ejemplo, tengo campo1 con "blabla", si lo cambiaba a campo1 = "bleble",
+            //ese campo1 con "blabla" ya iba a ser la versión vieja, pero si buscaba por ese blabla, si me iba a seguir apareciendo.
+            bundle_ids: filters?.bundle_ids,
+            item_ids: filters?.item_ids,
+            startDate: filters?.startDate,
+            endDate: filters?.endDate,
+        });
+        const response = await httpGraphQLAPI.post("", {
+            query: queryBuilded,
+            variables: {
+                agency_id,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        const registers = response?.data?.data?.submission_invoices;
+        // Filtrar los registros para obtener sólo los de la versión más alta.
+        const groupedByVersion = registers.reduce((acc, record) => {
+            const zid = record.settings_form_submission.zid;
+            if (!acc[zid]) {
+                acc[zid] = record;
+            }
+            return acc;
+        }, {});
+        let latestVersionRecords = Object.values(groupedByVersion).reverse();
+        //aplico el filtro de somevalue
+        if (filters?.some_field_value) {
+            latestVersionRecords = latestVersionRecords.filter((x) => x.settings_form_submission.settings_form_submission_values.some((y) => y.value === filters?.some_field_value));
+        }
+        return latestVersionRecords;
+    });
+}
+/**
+ * getMyCaseFormSubmissions
+ */
+export async function getMyCaseFormSubmissions(headersZauru, session, filters = {}, config = { withFiles: false }) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getMyCaseFormSubmissionsStringQuery({
+                formZid: filters?.formZid,
+                caseId: filters?.caseId,
+            }),
+            variables: {
+                responsible_id: session.get("employee_id"),
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        let registers = response?.data?.data?.submission_cases;
+        if (config.withFiles) {
+            registers = await Promise.all(registers.map(async (register) => {
+                const responseZauru = await httpZauru.get(`/settings/forms/form_submissions/${register.settings_form_submission.id}.json`, {
+                    headers: headersZauru,
+                });
+                register.settings_form_submission.settings_form_submission_values =
+                    register.settings_form_submission.settings_form_submission_values.map((x) => {
+                        if (x.settings_form_field.field_type === "image" ||
+                            x.settings_form_field.field_type === "file" ||
+                            x.settings_form_field.field_type === "pdf") {
+                            x.value = responseZauru.data[x.settings_form_field.print_var_name]
+                                ?.toString()
+                                .replace(/\\u0026/g, "&");
+                        }
+                        return x;
+                    });
+                return register;
+            }));
+        }
+        return registers;
+    });
+}
+/**
+ * getLastInvoiceFormSubmission
+ * @param session
+ * @param filters
+ * @returns
+ */
+export async function getLastInvoiceFormSubmission(session, filters = {}) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getLastInvoiceFormSubmissionStringQuery({
+                formZid: filters?.formZid,
+            }),
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        const register = response?.data?.data?.submission_invoices[0];
+        return register;
+    });
+}
+/**
+ * getInvoiceFormSubmissionsByInvoiceId
+ */
+export async function getInvoiceFormSubmissionsByInvoiceId(session, invoice_id, filters = {}) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getInvoiceFormSubmissionsByInvoiceIdStringQuery({
+                formZid: filters?.formZid,
+            }),
+            variables: {
+                invoice_id,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        const registers = response?.data?.data?.submission_invoices;
+        // Filtrar los registros para obtener sólo los de la versión más alta.
+        const groupedByVersion = registers.reduce((acc, record) => {
+            const zid = record.settings_form_submission.zid;
+            if (!acc[zid]) {
+                acc[zid] = record;
+            }
+            return acc;
+        }, {});
+        const latestVersionRecords = Object.values(groupedByVersion).reverse();
+        return latestVersionRecords;
+    });
+}
+/**
+ * createForm
+ * @param headers
+ * @param body
+ */
+export async function createForm(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            ...body,
+            form_fields_attributes: arrayToObject(body.settings_form_fields),
+        };
+        delete sendBody.settings_form_fields;
+        const response = await httpZauru.post(`/settings/forms.json`, { settings_form: sendBody }, { headers });
+        return response.data;
+    });
+}
+/**
+ * deleteForm
+ * @param headers
+ * @param body
+ */
+export async function deleteForm(headers, id) {
+    return handlePossibleAxiosErrors(async () => {
+        await httpZauru.delete(`/settings/forms/${id}?destroy=true`, {
+            headers,
+        });
+        return true;
+    });
+}
+/**
+ * createForm
+ * @param headers
+ * @param body
+ */
+export async function updateForm(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            ...body,
+            form_fields_attributes: arrayToObject(body.settings_form_fields),
+        };
+        delete sendBody.settings_form_fields;
+        const response = await httpZauru.post(`/settings/forms.json`, { settings_form: sendBody }, { headers });
+        return response.data;
+    });
+}
+/**
+ * createFormSubmission
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createFormSubmission(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        delete headers["Content-type"];
+        const sendBody = convertToFormData({
+            settings_form_submission: body,
+        });
+        const response = await httpZauru.post(`/settings/forms/form_submissions.json`, sendBody, { headers });
+        return response.data;
+    });
+}
+/**
+ * updateSubmissionInvoiceFormSubmission
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function updateSubmissionInvoiceFormSubmission(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const settings_form_submission = {
+            form_id: body.settings_form_submission?.settings_form?.id,
+            reference: body.settings_form_submission?.reference,
+            document_type: "invoice",
+            document_id: body.invoice_id,
+            zid: body.settings_form_submission?.zid,
+            form_submission_values_attributes: arrayToObject(body.settings_form_submission?.settings_form_submission_values?.map((x) => {
+                delete x.settings_form_field;
+                return x;
+            })),
+        };
+        const response = await httpZauru.post(`/settings/forms/form_submissions.json`, {
+            settings_form_submission,
+        }, { headers });
+        return response.data;
+    });
+}
+/**
+ * deleteFormSubmission
+ * @param headers
+ * @param body
+ */
+export async function deleteFormSubmission(headers, id) {
+    return handlePossibleAxiosErrors(async () => {
+        await httpZauru.delete(`/settings/forms/form_submissions/${id}.json`, {
+            headers,
+        });
+        return true;
+    });
+}

package/dist/zauru/zauru-invoices.server.d.ts

@@ -0,0 +1,26 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, InvoiceGraphQL } from "@zauru-sdk/types";
+/**
+ * getInvoicesByAgencyId
+ */
+export declare function getInvoicesByAgencyId(session: Session, id: string | null): Promise<AxiosUtilsResponse<InvoiceGraphQL[]>>;
+/**
+ * createInvoiceOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export declare function createInvoiceOrder(headers: any, body: Partial<InvoiceGraphQL>): Promise<AxiosUtilsResponse<InvoiceGraphQL>>;
+/**
+ * updateInvoiceOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export declare function updateInvoiceOrder(headers: any, body: Partial<InvoiceGraphQL>): Promise<AxiosUtilsResponse<InvoiceGraphQL>>;
+/**
+ * deleteInvoice
+ * @param headers
+ * @param body
+ */
+export declare function deleteInvoiceOrder(headers: any, id: string | number): Promise<AxiosUtilsResponse<boolean>>;

package/dist/zauru/zauru-invoices.server.js

@@ -0,0 +1,94 @@
+import { arrayToObject, handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getInvoicesByAgencyIdStringQuery } from "@zauru-sdk/graphql";
+import httpZauru from "./httpZauru.server.js";
+/**
+ * getInvoicesByAgencyId
+ */
+export async function getInvoicesByAgencyId(session, id) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getInvoicesByAgencyIdStringQuery,
+            variables: {
+                id,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        // Filtrar los registros para obtener sólo los de la versión más alta.
+        const registers = response?.data?.data?.invoices.map((x) => {
+            const groupedByVersion = x.submission_invoices?.reduce((acc, record) => {
+                const zid = record.settings_form_submission?.zid;
+                if (!acc[zid]) {
+                    acc[zid] = record;
+                }
+                return acc;
+            }, {});
+            x.submission_invoices = Object.values(groupedByVersion)?.reverse() ?? [];
+            return x;
+        });
+        return registers;
+    });
+}
+/**
+ * createInvoiceOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createInvoiceOrder(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            ...body,
+            issued: false, // Esto lo hace una órden y no una factura
+            invoice_details_attributes: arrayToObject(body.invoice_details),
+            tag_ids: body.tagging_invoices?.map((x) => x.tag_id) ?? [],
+        };
+        if (sendBody.deleted_invoice_details)
+            delete sendBody.deleted_invoice_details;
+        if (sendBody.__rvfInternalFormId)
+            delete sendBody.__rvfInternalFormId;
+        if (sendBody.invoice_details)
+            delete sendBody.invoice_details;
+        const response = await httpZauru.post(`/sales/orders.json`, { invoice: sendBody }, { headers });
+        return response.data;
+    });
+}
+/**
+ * updateInvoiceOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function updateInvoiceOrder(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            ...body,
+            invoice_details_attributes: arrayToObject(body.invoice_details),
+        };
+        if (sendBody.deleted_invoice_details)
+            delete sendBody.deleted_invoice_details;
+        if (sendBody.__rvfInternalFormId)
+            delete sendBody.__rvfInternalFormId;
+        if (sendBody.invoice_details)
+            delete sendBody.invoice_details;
+        const response = await httpZauru.patch(`/sales/orders/${body.id}.json`, { invoice: sendBody }, { headers });
+        return response.data;
+    });
+}
+/**
+ * deleteInvoice
+ * @param headers
+ * @param body
+ */
+export async function deleteInvoiceOrder(headers, id) {
+    return handlePossibleAxiosErrors(async () => {
+        await httpZauru.get(`/sales/orders/${id}/void`, {
+            headers,
+        });
+        return true;
+    });
+}

package/dist/zauru/zauru-items.server.d.ts

@@ -0,0 +1,91 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, ItemCategoryGraphQL, ItemGraphQL, ItemSuperCategoryGraphQL } from "@zauru-sdk/types";
+/**
+ * getItems
+ */
+export declare function getItems(session: Session): Promise<AxiosUtilsResponse<ItemGraphQL[]>>;
+/**
+ * getItemByName
+ */
+export declare function getItemByName(session: Session, name: string): Promise<AxiosUtilsResponse<ItemGraphQL>>;
+/**
+ * getItemCategories
+ * @param headers
+ * @param agency_id
+ * @returns
+ */
+export declare function getItemCategories(headers: any, item_category_id: string): Promise<ItemCategoryGraphQL>;
+/**
+ * getItemsByCategoryId
+ */
+export declare function getItemsByCategoryId(session: Session, id: string): Promise<AxiosUtilsResponse<ItemGraphQL[]>>;
+/**
+ * getItemCategory
+ * @param session
+ * @param id
+ */
+export declare function getItemCategory(session: Session, id: number | string): Promise<AxiosUtilsResponse<ItemCategoryGraphQL | undefined>>;
+/**
+ * getItemCategoriesBySuperCategoryId
+ * @param session
+ * @param categoryId
+ * @returns
+ */
+export declare function getItemCategoriesBySuperCategoryId(session: Session, id: number | string): Promise<AxiosUtilsResponse<ItemCategoryGraphQL[]>>;
+/**
+ * getItemsBySuperCategoryId
+ * @param session
+ * @param categoryId
+ * @returns
+ */
+export declare function getItemsBySuperCategoryId(session: Session, id: number | string, agency_id: number | string): Promise<AxiosUtilsResponse<ItemGraphQL[]>>;
+/**
+ * createItemSuperCategory
+ * @param session
+ * @param headers
+ * @returns
+ */
+export declare function createItemSuperCategory(headers: any, body: Partial<ItemSuperCategoryGraphQL>): Promise<AxiosUtilsResponse<ItemSuperCategoryGraphQL>>;
+/**
+ * createItemCategory
+ * @param session
+ * @param headers
+ * @returns
+ */
+export declare function createItemCategory(headers: any, body: Partial<ItemCategoryGraphQL>): Promise<AxiosUtilsResponse<ItemCategoryGraphQL>>;
+/**
+ * deleteItemCategory
+ * @param headers
+ * @param id
+ * @returns
+ */
+export declare function deleteItemCategory(headers: any, id: string | number): Promise<AxiosUtilsResponse<boolean>>;
+/**
+ * updatePayee
+ * @param session
+ * @param headers
+ * @returns
+ */
+export declare function updateItemCategory(headers: any, body: Partial<ItemCategoryGraphQL>): Promise<AxiosUtilsResponse<boolean>>;
+/**
+ * createItem
+ * @param headers
+ * @param body
+ * @returns
+ */
+export declare function createItem(headers: any, body: Partial<ItemGraphQL>): Promise<AxiosUtilsResponse<ItemGraphQL>>;
+/**
+ * updateItem
+ * @param headers
+ * @param body
+ * @param id
+ * @returns
+ */
+export declare function updateItem(headers: any, body: Partial<ItemGraphQL>): Promise<AxiosUtilsResponse<boolean>>;
+/**
+ * deleteItemCategory
+ * @param headers
+ * @param id
+ * @returns
+ */
+export declare function deleteItem(headers: any, id: string | number): Promise<AxiosUtilsResponse<boolean>>;