@zauru-sdk/utils 1.0.7 → 1.0.9

package/dist/zauru/discharges-histsory.utils.js

@@ -0,0 +1,46 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { createWebAppTableRegister, getVariablesByName, getWebAppTableRegisters, updateWebAppTableRegister, } from "@zauru-sdk/services";
+/**
+ * Get getDischargeHistories from the web app table.
+ * @param headers Request headers.
+ * @param session Session object.
+ * @returns A Promise of AxiosUtilsResponse<DischargeHistory[]>.
+ */
+export async function getDischargeHistories(headers, session) {
+    return handlePossibleAxiosErrors(async () => {
+        const { discharge_history_web_app_table_id } = await getVariablesByName(headers, session, ["discharge_history_web_app_table_id"]);
+        const response = await getWebAppTableRegisters(session, discharge_history_web_app_table_id);
+        if (response.error) {
+            throw new Error(`Ocurrió un error al consultar el historial de discharges: ${response.userMsg}`);
+        }
+        const history = response?.data ?? [];
+        return history;
+    });
+}
+/**
+ * Create a template in the web app table.
+ * @param headers Request headers.
+ * @param session Session object.
+ * @param body DischargeHistory data to be created.
+ * @returns A Promise of AxiosUtilsResponse<DischargeHistory>.
+ */
+export async function createDischargeHistory(headers, session, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const { discharge_history_web_app_table_id } = await getVariablesByName(headers, session, ["discharge_history_web_app_table_id"]);
+        const response = await createWebAppTableRegister(headers, discharge_history_web_app_table_id, body);
+        return response;
+    });
+}
+/**
+ * Put updateDischargeHistory from the web app table.
+ * @param headers Request headers.
+ * @param session Session object.
+ * @returns A Promise of AxiosUtilsResponse<DischargeHistory[]>.
+ */
+export async function updateDischargeHistory(headers, session, body, id_registro) {
+    return handlePossibleAxiosErrors(async () => {
+        const { discharge_history_web_app_table_id } = await getVariablesByName(headers, session, ["discharge_history_web_app_table_id"]);
+        const response = await updateWebAppTableRegister(headers, discharge_history_web_app_table_id, id_registro, { ...body });
+        return response;
+    });
+}

package/dist/zauru/employees.utils.d.ts

@@ -0,0 +1,16 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, EmployeeGraphQL } from "@zauru-sdk/types";
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getEmployeesByLabAgency: (headers: any, session: Session) => Promise<AxiosUtilsResponse<EmployeeGraphQL[]>>;
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getEmployeesByCurrentAgency: (session: Session) => Promise<AxiosUtilsResponse<EmployeeGraphQL[]>>;

package/dist/zauru/employees.utils.js

@@ -0,0 +1,39 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { getEmployeesByAgencyId, getVariablesByName, } from "@zauru-sdk/services";
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const getEmployeesByLabAgency = async (headers, session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_agency_id } = await getVariablesByName(headers, session, [
+            "lab_agency_id",
+        ]);
+        const response = await getEmployeesByAgencyId(session, lab_agency_id);
+        if (response.error) {
+            const msg = `Ocurrió un error al consultar los empleados por agencia de laboratorio: ${response.userMsg}`;
+            console.error(msg);
+            throw new Error(msg);
+        }
+        return response?.data ?? [];
+    });
+};
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const getEmployeesByCurrentAgency = async (session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await getEmployeesByAgencyId(session, session.get("agency_id"));
+        if (response.error) {
+            const msg = `Ocurrió un error al consultar los empleados por la agencia actual: ${response.userMsg}`;
+            console.error(msg);
+            throw new Error(msg);
+        }
+        return response?.data ?? [];
+    });
+};

package/dist/zauru/form.utils.d.ts

@@ -0,0 +1,34 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, SubmissionInvoicesGraphQL, TransformedObject } from "@zauru-sdk/types";
+export declare function transformFormSubmitObject(input: {
+    [key: string]: any;
+}): TransformedObject;
+type OutputData = {
+    index: number;
+    item_id: number;
+    form_id?: number;
+    document_id: number;
+    reference?: string;
+    zid?: string;
+    fields: {
+        [field_id: number]: string;
+    }[];
+};
+export declare function transformResultadosFormData(input: {
+    [key: string]: string;
+}, document_id: number): OutputData[];
+/**
+ *
+ * @param data
+ * @returns
+ */
+export declare const createRespuestaFormSubmission: (headers: any, data: OutputData) => Promise<AxiosUtilsResponse<any>>;
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getLastMuestra: (headers: any, session: Session) => Promise<AxiosUtilsResponse<SubmissionInvoicesGraphQL>>;
+export declare const getMuestrasByInvoiceId: (headers: any, session: Session, invoice_id: string) => Promise<AxiosUtilsResponse<SubmissionInvoicesGraphQL[]>>;
+export {};

package/dist/zauru/form.utils.js

@@ -0,0 +1,152 @@
+import { arrayToObject, handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { createFormSubmission, getInvoiceFormSubmissionsByInvoiceId, getLastInvoiceFormSubmission, getVariablesByName, } from "@zauru-sdk/services";
+export function transformFormSubmitObject(input) {
+    const form_submission_values = [];
+    // Itera sobre las propiedades del objeto
+    for (const key in input) {
+        // Utiliza una expresión regular para detectar claves que coinciden con el patrón 'word_number'
+        const match = key.match(/^(.+?)_(\d+)$/);
+        if (match) {
+            const [, , form_field_id] = match;
+            let newObj = {
+                form_field_id,
+                groups_path: "[]",
+            };
+            if (input[key] instanceof File) {
+                const fileType = input[key].type;
+                newObj["value"] = "";
+                if (input[key]?.size > 0) {
+                    // Verifica si el archivo es una imagen
+                    if (fileType.startsWith("image/")) {
+                        newObj["image"] = input[key];
+                    }
+                    // Verifica si el archivo es un PDF
+                    else if (fileType === "application/pdf") {
+                        newObj["pdf"] = input[key];
+                    }
+                    // Cualquier otro tipo de archivo
+                    else {
+                        newObj["file"] = input[key];
+                    }
+                }
+            }
+            else {
+                newObj["value"] = input[key];
+            }
+            form_submission_values.push(newObj);
+        }
+    }
+    return {
+        form_submission_values_attributes: arrayToObject(form_submission_values),
+        form_id: input.form_id,
+        document_id: input.document_id,
+        zid: input.zid,
+        document_type: input.document_type,
+        reference: input.reference,
+        id_number: input.id_number ?? "",
+    };
+}
+export function transformResultadosFormData(input, document_id) {
+    const resultMap = {};
+    for (const [key, value] of Object.entries(input)) {
+        const parts = key.split("_");
+        if (parts.length === 3 &&
+            (parts[2] === "zid" || parts[2] === "reference")) {
+            const [index, item_id, specialField] = parts;
+            const compositeKey = `${index}_${item_id}`;
+            if (!resultMap[compositeKey]) {
+                resultMap[compositeKey] = {
+                    index: parseInt(index),
+                    item_id: parseInt(item_id),
+                    document_id,
+                    fields: [],
+                };
+            }
+            if (specialField === "zid") {
+                resultMap[compositeKey].zid = value;
+            }
+            else if (specialField === "reference") {
+                resultMap[compositeKey].reference = value;
+            }
+            continue;
+        }
+        if (parts.length !== 4)
+            continue;
+        if (parts.some((part) => isNaN(parseInt(part, 10))))
+            continue;
+        const [index, item_id, form_id, field_id] = parts.map((part) => parseInt(part, 10));
+        const compositeKey = `${index}_${item_id}`;
+        if (!resultMap[compositeKey]) {
+            resultMap[compositeKey] = {
+                index,
+                item_id,
+                form_id,
+                document_id,
+                fields: [],
+            };
+        }
+        resultMap[compositeKey].fields.push({ [field_id]: value });
+        resultMap[compositeKey].form_id = form_id;
+    }
+    return Object.values(resultMap);
+}
+/**
+ *
+ * @param data
+ * @returns
+ */
+export const createRespuestaFormSubmission = (headers, data) => {
+    return handlePossibleAxiosErrors(async () => {
+        const form_submission_values = [];
+        for (const value of data.fields) {
+            const form_field_id = Object.keys(value)[0];
+            const associatedValue = value[form_field_id];
+            form_submission_values.push({
+                form_field_id,
+                value: associatedValue,
+                groups_path: "[]",
+            });
+        }
+        const sendBody = {
+            form_id: data.form_id,
+            reference: `${data.index}_${data.item_id};${data?.reference}`,
+            document_type: "invoice",
+            document_id: data.document_id,
+            form_submission_values_attributes: arrayToObject(form_submission_values),
+            zid: data.zid,
+        };
+        const response = await createFormSubmission(headers, sendBody);
+        if (response.error) {
+            throw new Error(`Ocurrió un error al intentar crear la respuesta de formulario: ${data}`);
+        }
+        return true;
+    });
+};
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const getLastMuestra = (headers, session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_muestras_form_zid } = await getVariablesByName(headers, session, ["lab_muestras_form_zid"]);
+        const response = await getLastInvoiceFormSubmission(session, {
+            formZid: Number(lab_muestras_form_zid),
+        });
+        if (response.error || !response.data) {
+            throw new Error(`Ocurrió un error al intentar obtener la última muestra registrada: ${response.userMsg}`);
+        }
+        return response.data;
+    });
+};
+export const getMuestrasByInvoiceId = (headers, session, invoice_id) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_muestras_form_zid } = await getVariablesByName(headers, session, ["lab_muestras_form_zid"]);
+        const response = await getInvoiceFormSubmissionsByInvoiceId(session, invoice_id, { formZid: Number(lab_muestras_form_zid) });
+        if (response.error || !response.data) {
+            throw new Error(`Ocurrió un error al intentar obtener las muestras de la remisión: ${response.userMsg}`);
+        }
+        return response.data;
+    });
+};

package/dist/zauru/invoices.utils.d.ts

@@ -0,0 +1,22 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, InvoiceDetailsGraphQL, InvoiceGraphQL } from "@zauru-sdk/types";
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getInvoicesByLabAgency: (headers: any, session: Session) => Promise<AxiosUtilsResponse<InvoiceGraphQL[]>>;
+/**
+ * createNewLabInvoiceOrder
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const createNewLabInvoiceOrder: (headers: any, session: Session, body: Partial<InvoiceGraphQL>) => Promise<AxiosUtilsResponse<boolean>>;
+/**
+ * makeInvoiceDetailsWithPrice
+ * @param invoice_details
+ * @returns
+ */
+export declare const makeInvoiceDetailsWithPrice: (invoice_details: any[], deleted_invoice_details?: any[]) => InvoiceDetailsGraphQL[];

package/dist/zauru/invoices.utils.js

@@ -0,0 +1,79 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { createInvoiceOrder, getInvoicesByAgencyId, getVariablesByName, } from "@zauru-sdk/services";
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const getInvoicesByLabAgency = async (headers, session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_agency_id } = await getVariablesByName(headers, session, [
+            "lab_agency_id",
+        ]);
+        const response = await getInvoicesByAgencyId(session, lab_agency_id);
+        if (response.error) {
+            const msg = `Ocurrió un error al consultar las órdenes/facturas por agencia de laboratorio: ${response.userMsg}`;
+            console.error(msg);
+            throw new Error(msg);
+        }
+        return response?.data ?? [];
+    });
+};
+/**
+ * createNewLabInvoiceOrder
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const createNewLabInvoiceOrder = async (headers, session, body) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_agency_id, laboratory_proyect_id } = await getVariablesByName(headers, session, ["lab_agency_id", "laboratory_proyect_id"]);
+        const sendBody = {
+            ...body,
+            agency_id: Number(lab_agency_id),
+            tagging_invoices: [
+                { tag_id: Number(laboratory_proyect_id), id: 0, invoice_id: 0 },
+            ],
+        };
+        const bundleResponse = await createInvoiceOrder(headers, sendBody);
+        if (bundleResponse.error) {
+            const msg = `Ocurrió un error al intentar crear (invoice-order): ${bundleResponse.userMsg}`;
+            console.error(msg);
+            throw new Error(msg);
+        }
+        return true;
+    });
+};
+/**
+ * makeInvoiceDetailsWithPrice
+ * @param invoice_details
+ * @returns
+ */
+export const makeInvoiceDetailsWithPrice = (invoice_details, deleted_invoice_details = []) => {
+    return [
+        ...invoice_details.map((x) => {
+            //Si trae una B al inicio, es un bundleID, de lo contrario, es un item_id
+            const bundle_id = x.item_id?.startsWith("B")
+                ? Number(x.item_id.replace("B", ""))
+                : undefined;
+            const item_id = !bundle_id ? Number(x.item_id) : undefined;
+            const id = isNaN(x.id) ? undefined : x.id;
+            return {
+                id,
+                bundle_id,
+                item_id,
+                quantity: Number(x.quantity),
+                //unit_price: Number(x.price),
+                //price: Number(x.total),
+                _destroy: false,
+            };
+        }),
+        ...deleted_invoice_details.map((x) => {
+            return {
+                id: x.id,
+                _destroy: true,
+            };
+        }),
+    ];
+};

package/dist/zauru/items.utils.d.ts

@@ -0,0 +1,52 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, ItemGraphQL, SearchItemParams, ItemDataTable, ItemCategoryGraphQL } from "@zauru-sdk/types";
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getItemsByReceptionCategory: (headers: any, session: Session) => Promise<AxiosUtilsResponse<ItemGraphQL[]>>;
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getItemsByLabCategory: (headers: any, session: Session) => Promise<AxiosUtilsResponse<ItemGraphQL[]>>;
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getItemServicesByLabCategory: (headers: any, session: Session) => Promise<AxiosUtilsResponse<ItemGraphQL[]>>;
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export declare const getItemsDataTable: (headers: any, search: SearchItemParams) => Promise<AxiosUtilsResponse<ItemDataTable[]>>;
+/**
+ * getLabItemCategories
+ * @param session
+ * @param headers
+ * @returns
+ */
+export declare function getLabItemCategories(headers: any, session: Session): Promise<AxiosUtilsResponse<ItemCategoryGraphQL[]>>;
+/**
+ * createNewLaboratoryClient
+ * @param session
+ * @param headers
+ * @param body
+ * @returns
+ */
+export declare function createNewLaboratoryItemCategory(session: Session, headers: any, body: Partial<ItemCategoryGraphQL>): Promise<AxiosUtilsResponse<boolean>>;
+/**
+ * createNewLaboratoryItem
+ * @param session
+ * @param headers
+ * @param body
+ * @returns
+ */
+export declare function createNewLaboratoryItem(headers: any, body: Partial<ItemGraphQL>): Promise<AxiosUtilsResponse<ItemGraphQL>>;

package/dist/zauru/items.utils.js

@@ -0,0 +1,152 @@
+import { extractValueBetweenTags, handlePossibleAxiosErrors, } from "@zauru-sdk/common";
+import { createItem, createItemCategory, getItemCategoriesBySuperCategoryId, getItemsByCategoryId, getItemsBySuperCategoryId, getVariablesByName, } from "@zauru-sdk/services";
+import httpZauru from "@zauru-sdk/services/dist/zauru/httpZauru.server.js";
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const getItemsByReceptionCategory = async (headers, session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { recepciones_item_category_id } = await getVariablesByName(headers, session, ["recepciones_item_category_id"]);
+        const response = await getItemsByCategoryId(session, recepciones_item_category_id);
+        if (response.error) {
+            throw new Error(`Ocurrió un error al consultar los items por categoría de recepción: ${response.userMsg}`);
+        }
+        return response?.data ?? [];
+    });
+};
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const getItemsByLabCategory = async (headers, session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_super_category_item_id, lab_agency_id } = await getVariablesByName(headers, session, [
+            "lab_super_category_item_id",
+            "lab_agency_id",
+        ]);
+        const response = await getItemsBySuperCategoryId(session, lab_super_category_item_id, lab_agency_id);
+        if (response.error) {
+            throw new Error(`Ocurrió un error al consultar los items por categoría de laboratorio: ${response.userMsg}`);
+        }
+        return response?.data ?? [];
+    });
+};
+/**
+ *
+ * @param headers
+ * @param session
+ * @returns
+ */
+export const getItemServicesByLabCategory = async (headers, session) => {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_services_item_category_id } = await getVariablesByName(headers, session, ["lab_services_item_category_id"]);
+        const response = await getItemsByCategoryId(session, lab_services_item_category_id);
+        if (response.error) {
+            throw new Error(`Ocurrió un error al consultar los items-servicios por categoría de laboratorio: ${response.userMsg}`);
+        }
+        return response?.data ?? [];
+    });
+};
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export const getItemsDataTable = async (headers, search) => {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.post(`/settings/items/datatables.json`, search, { headers });
+        const items = response.data?.data?.map((x) => formatHTMLItemList(x)) ?? [];
+        return items;
+    });
+};
+//============================ FORMATEADO DE ITEMS
+function extractIdFromURL(input) {
+    const regex = /\/items\/(\d+)/;
+    const match = input.match(regex);
+    return match ? parseInt(match[1], 10) : -1;
+}
+function formatHTMLItemList(item) {
+    return {
+        zid: parseInt(extractValueBetweenTags(item.zid, "a"), 10),
+        itemId: extractIdFromURL(item.cod),
+        name: extractValueBetweenTags(item.name, "a"),
+        stck: extractValueBetweenTags(item.stck, "i") || null,
+        act: extractValueBetweenTags(item.act, "i") || null,
+        sell: extractValueBetweenTags(item.sell, "i") || null,
+        purch: extractValueBetweenTags(item.purch, "i") || null,
+        vat: extractValueBetweenTags(item.vat, "i") || null,
+        cat: item.cat,
+        warr: item.warr,
+        cat_note: item.cat_note,
+        DT_RowId: parseInt(item.DT_RowId.replace("settings-item-", ""), 10),
+    };
+}
+/**
+ * getLabItemCategories
+ * @param session
+ * @param headers
+ * @returns
+ */
+export async function getLabItemCategories(headers, session) {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_super_category_item_id } = await getVariablesByName(headers, session, ["lab_super_category_item_id"]);
+        const response = await getItemCategoriesBySuperCategoryId(session, lab_super_category_item_id);
+        if (response.error || !response.data) {
+            throw new Error(response.userMsg);
+        }
+        return response.data;
+    });
+}
+/**
+ * createNewLaboratoryClient
+ * @param session
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createNewLaboratoryItemCategory(session, headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const { lab_super_category_item_id } = await getVariablesByName(headers, session, ["lab_super_category_item_id"]);
+        const sendBody = {
+            ...body,
+            item_super_category_id: Number(lab_super_category_item_id),
+            color: "#ff0000",
+        };
+        const createResponse = await createItemCategory(headers, sendBody);
+        if (!createResponse.data) {
+            throw new Error(`Ocurrió un error al intentar crear el item category: ${createResponse.userMsg}`);
+        }
+        return true;
+    });
+}
+/**
+ * createNewLaboratoryItem
+ * @param session
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createNewLaboratoryItem(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            active: true,
+            sellable: true,
+            quotable: true,
+            ecommerce: false,
+            purchasable: true,
+            weight: 0,
+            color: "#cccccc",
+            ...body,
+        };
+        const createResponse = await createItem(headers, sendBody);
+        if (!createResponse.data || createResponse.error) {
+            throw new Error(`Ocurrió un error al intentar crear el item: ${createResponse.userMsg}`);
+        }
+        return createResponse.data;
+    });
+}

package/dist/zauru/lotes.utils.d.ts

@@ -0,0 +1,31 @@
+import type { Session } from "@remix-run/node";
+import { BasketSchema } from "@zauru-sdk/types";
+/**
+ * Obtiene el listado de ordenes de compra, formateado especialmente para armar la tabla de edición de porcentajes de rechazo
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getLotesFormated: (headers: any, session: Session) => Promise<import("@zauru-sdk/types").LoteSchema[]>;
+/**
+ * procesarLote
+ * @param headers
+ * @param session
+ * @param data
+ * @param byPercent
+ */
+export declare const procesarLote: (headers: any, session: Session, data: any, poId: number | string) => Promise<void>;
+/**
+ * Obtiene toda la información de lote, con las canastas y razones de rechazo
+ * @param headers
+ * @param session
+ * @returns
+ */
+export declare const getLoteDescription: (headers: any, session: Session, lote_id: number) => Promise<{
+    lote: import("@zauru-sdk/types").LoteDescription;
+    purchase_order: import("@zauru-sdk/types").PurchasesDataTableListFormatedSchema;
+    purchase: (import("@zauru-sdk/types").PurchaseOrderGraphQL & {
+        baskets_memo: BasketSchema[];
+        baskets_memo_quantity: number;
+    }) | undefined;
+}>;