@zauru-sdk/services 1.0.6 → 1.0.8

package/dist/zauru/zauru-purchase-orders.server.js

@@ -0,0 +1,414 @@
+import { arrayToObject, convertToFormData, formatDateToUTC, getBasketsSchema, handlePossibleAxiosErrors, reduceAdd, } from "@zauru-sdk/common";
+import { createNewLotPurchaseOrderReception, createNewPurchaseOrderReception, } from "./zauru-receptions.server.js";
+import httpZauru from "./httpZauru.server.js";
+import { getGraphQLAPIHeaders, getVariablesByName } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getLast100ReceptionsStringQuery, getPurchaseOrderByIdNumberStringQuery, getPurchaseOrderStringQuery, getPurchaseOrdersBetweenDatesStringQuery, } from "@zauru-sdk/graphql";
+/**
+ * markAsReceivePurchaseOrder
+ * Esta función sólo se utiliza cuando se van a marcar como recibida toda la órden de compra, se recibe todo lo que se envío
+ * si se quiere recibir parcialmente, utilizar el endpoint de /receptions
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function markAsReceivePurchaseOrder(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = { ...body };
+        if (sendBody.fechaVencimiento) {
+            await receiveLotPurchaseOrder(headers, sendBody);
+        }
+        else {
+            await receivePurchaseOrder(headers, sendBody);
+        }
+        return true;
+    });
+}
+/**
+ * markAsReceivePartialPurchaseOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function markAsReceivePartialPurchaseOrder(headers, session, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = { ...body };
+        if (sendBody.fechaVencimiento) {
+            await createNewLotPurchaseOrderReception(headers, session, sendBody);
+        }
+        else {
+            await createNewPurchaseOrderReception(headers, session, body);
+        }
+        return true;
+    });
+}
+/**
+ *
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createNewPurchaseOrder(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        let sendBody = {
+            ...body,
+            purchase_order_details_attributes: arrayToObject(body?.purchase_order_details),
+            tag_ids: [
+                "",
+                ...(body?.taggings?.map((x) => x.tag_id?.toString()) ?? []),
+            ],
+        };
+        delete headers["Content-type"];
+        delete sendBody.__rvfInternalFormId;
+        delete sendBody.taggings;
+        delete sendBody.purchase_order_details;
+        if (!(sendBody?.pdf instanceof File) || sendBody.pdf?.size <= 0) {
+            delete sendBody.pdf;
+        }
+        sendBody = convertToFormData({
+            purchase_order: sendBody,
+        });
+        const response = await httpZauru.post(`/purchases/purchase_orders.json`, sendBody, { headers });
+        return response.data;
+    });
+}
+/**
+ *
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createNewAuthorizedPurchaseOrder(headers, body, withReceive = true) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            ...body,
+            purchase_order_details_attributes: arrayToObject(body?.purchase_order_details),
+        };
+        const response = await httpZauru.post(`/purchases/purchase_orders.json`, { purchase_order: sendBody }, { headers });
+        await httpZauru.get(`/purchases/purchase_orders/${response.data.id}/authorize.json`, { headers });
+        if (withReceive) {
+            if (sendBody.fechaVencimiento) {
+                await receiveLotPurchaseOrder(headers, response.data);
+            }
+            else {
+                await receivePurchaseOrder(headers, response.data);
+            }
+        }
+        return response.data;
+    });
+}
+/**
+ * receiveLotPurchaseOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function receiveLotPurchaseOrder(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            agency_id: body.agency_id,
+            delivery_date: body.issue_date,
+            id: body.id,
+            needs_transit: false,
+            purchase_order_details_attributes: arrayToObject(body.purchase_order_details?.map((x) => {
+                const newDetail = {
+                    id: x.id,
+                    booked_quantity: x.booked_quantity,
+                    item_id: x.item_id,
+                    lot_delivered_quantity: [x.delivered_quantity],
+                    lot_name: [body.id_number],
+                    lot_expire: [body.fechaVencimiento],
+                };
+                return newDetail;
+            })),
+        };
+        await httpZauru.patch(`/purchases/purchase_orders/${body.id}/receive_action`, { purchase_order: sendBody }, { headers });
+        return true;
+    });
+}
+/**
+ * receivePurchaseOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function receivePurchaseOrder(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            agency_id: body.agency_id,
+            delivery_date: body.issue_date,
+            id: body.id,
+            needs_transit: false,
+            purchase_order_details_attributes: arrayToObject(body.purchase_order_details?.map((x) => {
+                const newDetail = {
+                    id: x.id,
+                    delivered_quantity: x.delivered_quantity,
+                    booked_quantity: x.booked_quantity,
+                    item_id: x.item_id,
+                };
+                return newDetail;
+            })),
+        };
+        await httpZauru.patch(`/purchases/purchase_orders/${body.id}/receive_action`, { purchase_order: sendBody }, { headers });
+        return true;
+    });
+}
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export async function getNewPurchaseOrderInfo(headers) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.get("/purchases/purchase_orders/new.json", { headers });
+        const purchasersList = [];
+        response.data?.purchasers?.forEach((purchaser) => {
+            if (purchaser?.id) {
+                purchasersList.push({
+                    value: purchaser?.id,
+                    label: purchaser?.name,
+                });
+            }
+        });
+        return { ...response.data, purchasersList };
+    });
+}
+/**
+ * getPurchasesListDataTables Function for get all zauru orden-compras
+ * @param headers
+ * @returns
+ */
+export async function getPurchasesListDataTables(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.post(`/purchases/purchase_orders/datatables.json`, body, { headers });
+        return response.data;
+    });
+}
+/**
+ * getPurchasesList Function for get all zauru orden-compras
+ * @param headers
+ * @param params
+ * @returns
+ */
+export async function getPurchasesList(headers, session, params = {}, config) {
+    return handlePossibleAxiosErrors(async () => {
+        //Si quiere obtener los de producción, obtengo primero su agencia producción
+        if (config?.fromProduction) {
+            const { production_agency_id: temp_production_agency_id } = await getVariablesByName(headers, session, ["production_agency_id"]);
+            const hashProductionAgencyId = JSON.parse(temp_production_agency_id ?? "{}");
+            const production_agency_id = hashProductionAgencyId[session.get("agency_id")];
+            params.agency_id = production_agency_id;
+        }
+        const response = await httpZauru.get(`/purchases/purchase_orders/export.json`, {
+            headers,
+            params,
+        });
+        return response.data;
+    });
+}
+/**
+ * getPurchase Function for get an especific purchase order
+ * @param headers
+ * @returns
+ */
+export async function getPurchase(headers, purchase_order_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru(`/purchases/purchase_orders/${purchase_order_id}.json`, { method: "GET", headers });
+        const baskets_memo = getBasketsSchema(response.data.memo);
+        const baskets_memo_quantity = baskets_memo
+            .map((basket) => basket.total)
+            .reduce(reduceAdd, 0);
+        return {
+            ...response.data,
+            baskets_memo,
+            baskets_memo_quantity,
+        };
+    });
+}
+/**
+ * enablePurchase Enable a purchase order
+ * @param headers
+ * @param purchase_order_id
+ * @param reception_id
+ * @returns
+ */
+export async function enablePurchase(headers, purchase_order_id, reception_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.get(`/purchases/receptions/${reception_id}/rebound.json?purchase_order_id=${purchase_order_id}`, { headers });
+        return response.data;
+    });
+}
+/**
+ * updatePurchaseOrder
+ * @param headers
+ * @param body
+ * @param purchase_order_id
+ * @returns
+ */
+export async function updatePurchaseOrder(headers, body, purchase_order_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.patch(`/purchases/purchase_orders/${purchase_order_id}.json`, body, { headers });
+        return response.data;
+    });
+}
+/**
+ * updatePurchaseOrder
+ * @param headers
+ * @param body
+ * @param purchase_order_id
+ * @returns
+ */
+export async function updateReceivedPurchaseOrder(headers, body, purchase_order_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.patch(`/purchases/purchase_orders/${purchase_order_id}/update_received.json`, body, { headers });
+        return response.data;
+    });
+}
+/**
+ * getLast100Receptions
+ * @param headers
+ * @returns
+ */
+export async function getLast100Receptions(session, agency_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getLast100ReceptionsStringQuery,
+            variables: {
+                agencyId: agency_id ?? session.get("agency_id"),
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        return response.data?.data?.purchase_orders;
+    });
+}
+/**
+ * getPurchaseOrder
+ * @param headers
+ * @returns
+ */
+export async function getPurchaseOrder(session, poId, config = {
+    withLotStocksToMyAgency: false,
+}) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getPurchaseOrderStringQuery({
+                withLotStocks: config.withLotStocksToMyAgency,
+            }),
+            variables: {
+                id: poId,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        const tempResponse = response.data?.data?.purchase_orders[0];
+        if (config.withLotStocksToMyAgency) {
+            tempResponse.lots[0].lot_stocks = tempResponse.lots[0].lot_stocks.filter((x) => x.agency_id === Number(session.get("agency_id")));
+        }
+        return tempResponse;
+    });
+}
+/**
+ * getPurchaseOrder
+ * @param headers
+ * @returns
+ */
+export async function getGraphQLPurchaseOrderBetweenDates(session, dates, config = {
+    agencyFilter: true,
+    consolidateIdFilter: false,
+    useProductionAgencyId: false,
+    withShipmentToMyAgency: false,
+    withLotStocksToMyAgency: false,
+}) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        let agency_id = config.agencyId;
+        if (config.useProductionAgencyId) {
+            const { production_agency_id /**{5693: 5696} */ } = await getVariablesByName(headers, session, ["production_agency_id"]);
+            const hashAgencyId = JSON.parse(production_agency_id ?? "{}");
+            agency_id = hashAgencyId[session.get("agency_id")];
+        }
+        const query = getPurchaseOrdersBetweenDatesStringQuery({
+            agencyFilter: config.agencyFilter,
+            consolidateIdFilter: config.consolidateIdFilter,
+            lotItemIdExclusion: config.lotItemIdExclusion,
+            poDetailTagId: config.poDetailTagId,
+            withLotStocks: config.withLotStocksToMyAgency,
+            //itemId: config.itemId,
+            //payeeCategoryId: config.payeeCategoryId,
+        });
+        const variables = {
+            ...(config.agencyFilter
+                ? { agencyId: agency_id ?? session.get("agency_id") }
+                : {}),
+            ...(config.lotItemIdExclusion
+                ? { lotItemIdExclusion: config.lotItemIdExclusion }
+                : {}),
+            ...(config.poDetailTagId ? { poDetailTagId: config.poDetailTagId } : {}),
+            startDate: formatDateToUTC(dates.startDate),
+            endDate: formatDateToUTC(dates.endDate),
+        };
+        const response = await httpGraphQLAPI.post("", {
+            query,
+            variables,
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        //============ Aplicación de filtros
+        let responseData = [];
+        if (config.withShipmentToMyAgency) {
+            responseData = response.data?.data?.purchase_orders.filter((x) => x.shipment_purchase_orders.some((y) => y.shipment.agency_to_id?.toString() == session.get("agency_id")));
+        }
+        if (config.withLotStocksToMyAgency) {
+            responseData = responseData.map((x) => {
+                x.lots = x.lots.map((y) => {
+                    y.lot_stocks = y.lot_stocks.filter((z) => z.agency_id == session.get("agency_id"));
+                    return y;
+                });
+                return x;
+            });
+        }
+        return responseData;
+    });
+}
+/**
+ * deletePurchaseOrder
+ * @param headers
+ * @param id
+ * @returns
+ */
+export async function deletePurchaseOrder(headers, id) {
+    return handlePossibleAxiosErrors(async () => {
+        await httpZauru.delete(`/purchases/purchase_orders/${id}.json?destroy=true`, { headers });
+        return true;
+    });
+}
+/**
+ * getPurchaseOrderByIdNumber
+ * @param session
+ * @param idNumber
+ * @returns
+ */
+export async function getPurchasesOrderByIdNumber(session, id_number) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getPurchaseOrderByIdNumberStringQuery,
+            variables: {
+                id_number,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        if (!response?.data?.data.purchase_orders) {
+            return [];
+        }
+        return response.data?.data?.purchase_orders;
+    });
+}

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

@@ -0,0 +1,33 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, NewReceptionBody, PurchaseOrderGraphQL } from "@zauru-sdk/types";
+/**
+ * createNewReception
+ * @param headers
+ * @param body
+ * @param purchase_order_id
+ * @returns
+ */
+export declare function createNewReception(headers: any, body: NewReceptionBody, purchase_order_id: number | string): Promise<AxiosUtilsResponse<any>>;
+/**
+ * deleteReception
+ * @param headers
+ * @param id
+ * @returns
+ */
+export declare function deleteReception(headers: any, receptionId: string | number, poId: string | number): Promise<AxiosUtilsResponse<boolean>>;
+/**
+ *
+ * @param headers
+ * @param poId
+ * @returns
+ */
+export declare function createNewPurchaseOrderReception(headers: any, session: Session, body: Partial<PurchaseOrderGraphQL>): Promise<AxiosUtilsResponse<boolean>>;
+/**
+ *
+ * @param headers
+ * @param poId
+ * @returns
+ */
+export declare function createNewLotPurchaseOrderReception(headers: any, session: Session, body: Partial<PurchaseOrderGraphQL> & {
+    fechaVencimiento: string;
+}): Promise<AxiosUtilsResponse<boolean>>;

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

@@ -0,0 +1,94 @@
+import { arrayToObject, getDatePickerCurrentDate, handlePossibleAxiosErrors, } from "@zauru-sdk/common";
+import httpZauru from "./httpZauru.server.js";
+/**
+ * createNewReception
+ * @param headers
+ * @param body
+ * @param purchase_order_id
+ * @returns
+ */
+export async function createNewReception(headers, body, purchase_order_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru(`/purchases/purchase_orders/${purchase_order_id}/receptions.json`, { method: "POST", headers, data: body });
+        return response.data;
+    });
+}
+/**
+ * deleteReception
+ * @param headers
+ * @param id
+ * @returns
+ */
+export async function deleteReception(headers, receptionId, poId) {
+    return handlePossibleAxiosErrors(async () => {
+        await httpZauru.get(`/purchases/receptions/${receptionId}/rebound.json?purchase_order_id=${poId}`, {
+            headers,
+        });
+        return true;
+    });
+}
+/**
+ *
+ * @param headers
+ * @param poId
+ * @returns
+ */
+export async function createNewPurchaseOrderReception(headers, session, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            reception: {
+                memo: "LABORATORIO - Recibido parcialmente desde WebApp",
+                purchase_order_id: body.id,
+                needs_transit: false,
+                agency_id: session.get("agency_id"),
+                entity_id: session.get("selectedEntity"),
+                received_at: getDatePickerCurrentDate(),
+                invoice_number: "",
+                reception_details_attributes: arrayToObject(body?.purchase_order_details?.map((x) => {
+                    return {
+                        item_id: x.item_id,
+                        purchase_order_detail_id: x.id,
+                        quantity: x.delivered_quantity,
+                    };
+                })),
+            },
+            purchase_order_id: body.id,
+        };
+        await httpZauru.post(`/purchases/purchase_orders/${body.id}/receptions.json`, sendBody, {
+            headers,
+        });
+        return true;
+    });
+}
+/**
+ *
+ * @param headers
+ * @param poId
+ * @returns
+ */
+export async function createNewLotPurchaseOrderReception(headers, session, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const sendBody = {
+            memo: "LABORATORIO - Recibido parcialmente desde WebApp",
+            purchase_order_id: body.id,
+            needs_transit: false,
+            received_at: getDatePickerCurrentDate(),
+            invoice_number: "",
+            agency_id: session.get("agency_id"),
+            entity_id: session.get("selectedEntity"),
+            reception_details_attributes: arrayToObject(body?.purchase_order_details?.map((x) => {
+                return {
+                    item_id: x.item_id,
+                    purchase_order_detail_id: x.id,
+                    lot_delivered_quantity: [x.delivered_quantity],
+                    lot_name: [body.id_number],
+                    lot_expire: [body.fechaVencimiento],
+                };
+            })),
+        };
+        await httpZauru.post(`/purchases/purchase_orders/${body.id}/receptions.json`, { reception: sendBody, purchase_order_id: body.id }, {
+            headers,
+        });
+        return true;
+    });
+}

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

@@ -0,0 +1,20 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, ShipmentGraphQL } from "@zauru-sdk/types";
+/**
+ * getShipmentsByToAgencyLast100Id_booking
+ */
+export declare function getShipmentsByToAgencyLast100Id_booking(session: Session, agency_to_id: string | number): Promise<AxiosUtilsResponse<ShipmentGraphQL[]>>;
+/**
+ * receiveShipment_booking
+ * @param headers
+ * @param id
+ * @returns
+ */
+export declare function receiveShipment_booking(headers: any, id: string | number): Promise<AxiosUtilsResponse<boolean>>;
+/**
+ * deleteShipment_booking
+ * @param headers
+ * @param id
+ * @returns
+ */
+export declare function deleteShipment_booking(headers: any, id: string | number): Promise<AxiosUtilsResponse<boolean>>;

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

@@ -0,0 +1,53 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getShipmentsByToAgencyLast100StringQuery } from "@zauru-sdk/graphql";
+import httpZauru from "./httpZauru.server.js";
+/**
+ * getShipmentsByToAgencyLast100Id_booking
+ */
+export async function getShipmentsByToAgencyLast100Id_booking(session, agency_to_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getShipmentsByToAgencyLast100StringQuery,
+            variables: {
+                agency_to_id,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        const registers = response?.data?.data?.shipments;
+        return registers;
+    });
+}
+/**
+ * receiveShipment_booking
+ * @param headers
+ * @param id
+ * @returns
+ */
+export async function receiveShipment_booking(headers, id) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.get(`/inventories/bookings/${id}/deliver.json`, { headers });
+        if (!response.data) {
+            throw new Error("Sin respuesta de: /inventories/bookings/id/deliver.json");
+        }
+        return true;
+    });
+}
+/**
+ * deleteShipment_booking
+ * @param headers
+ * @param id
+ * @returns
+ */
+export async function deleteShipment_booking(headers, id) {
+    return handlePossibleAxiosErrors(async () => {
+        await httpZauru.delete(`/inventories/bookings/${id}.json`, {
+            headers,
+        });
+        return true;
+    });
+}

package/dist/zauru/zauru-suggested-prices.server.d.ts

@@ -0,0 +1,30 @@
+import { AxiosUtilsResponse, ItemWithPrices, SuggestedPriceGraphQL } from "@zauru-sdk/types";
+import { Session } from "@remix-run/node";
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export declare const getSuggestedPricesExportJSON: (headers: any) => Promise<AxiosUtilsResponse<ItemWithPrices[]>>;
+/**
+ * getSuggestedPrices
+ * @param session
+ * @param id
+ */
+export declare function getSuggestedPrices(session: Session, config: {
+    notNullPriceList?: boolean;
+    withItems?: boolean;
+    withItemCategories?: boolean;
+}): Promise<AxiosUtilsResponse<SuggestedPriceGraphQL[]>>;
+/**
+ * createSuggestedPrice
+ * @param headers
+ * @param body
+ */
+export declare function createSuggestedPrice(headers: any, body: Partial<SuggestedPriceGraphQL>): Promise<AxiosUtilsResponse<SuggestedPriceGraphQL>>;
+/**
+ * deleteSuggestedPrice
+ * @param headers
+ * @param body
+ */
+export declare function deleteSuggestedPrice(headers: any, id: string | number): Promise<AxiosUtilsResponse<boolean>>;