@zauru-sdk/services 1.0.6 → 1.0.8

package/dist/zauru/zauru-suggested-prices.server.js

@@ -0,0 +1,83 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import httpZauru from "./httpZauru.server.js";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getSuggestedPricesStringQuery } from "@zauru-sdk/graphql";
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export const getSuggestedPricesExportJSON = async (headers) => {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.get(`/sales/suggested_prices/export.json`, {
+            headers,
+        });
+        return response.data;
+    });
+};
+/**
+ * getSuggestedPrices
+ * @param session
+ * @param id
+ */
+export async function getSuggestedPrices(session, config) {
+    return handlePossibleAxiosErrors(async () => {
+        const { notNullPriceList = false, withItems = false, withItemCategories = false, } = config;
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getSuggestedPricesStringQuery({
+                notNullPriceList,
+                withItems,
+                withItemCategories,
+            }),
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        return response?.data?.data?.suggested_prices ?? [];
+    });
+}
+/**
+ * createSuggestedPrice
+ * @param headers
+ * @param body
+ */
+export async function createSuggestedPrice(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.post(`/sales/suggested_prices.json`, { suggested_price: body }, { headers });
+        return response.data;
+    });
+}
+//No existe actualizar
+// /**
+//  * updateSuggestedPrice
+//  * @param headers
+//  * @param body
+//  */
+// export async function updateSuggestedPrice(
+//   headers: any,
+//   body: Partial<SuggestedPriceGraphQL>
+// ): Promise<AxiosUtilsResponse<SuggestedPriceGraphQL>> {
+//   return handlePossibleAxiosErrors(async () => {
+//     const response = await httpZauru.patch<SuggestedPriceGraphQL>(
+//       `/sales/suggested_prices.json`,
+//       { suggested_price: body },
+//       { headers }
+//     );
+//     return response.data;
+//   });
+// }
+/**
+ * deleteSuggestedPrice
+ * @param headers
+ * @param body
+ */
+export async function deleteSuggestedPrice(headers, id) {
+    return handlePossibleAxiosErrors(async () => {
+        await httpZauru.delete(`/sales/suggested_prices/${id}?destroy=true`, {
+            headers,
+        });
+        return true;
+    });
+}

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

@@ -0,0 +1,7 @@
+import { AxiosUtilsResponse, TagGraphQL } from "@zauru-sdk/types";
+/**
+ * createTag
+ * @param headers
+ * @param body
+ */
+export declare function createTag(headers: any, body: Partial<TagGraphQL>): Promise<AxiosUtilsResponse<TagGraphQL>>;

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

@@ -0,0 +1,13 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import httpZauru from "./httpZauru.server.js";
+/**
+ * createTag
+ * @param headers
+ * @param body
+ */
+export async function createTag(headers, body) {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.post(`/settings/tags.json`, { tag: body }, { headers });
+        return response.data;
+    });
+}

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

@@ -0,0 +1,7 @@
+import { AxiosUtilsResponse } from "@zauru-sdk/types";
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export declare const getReceptionTemplate: (headers: any, id: string | number) => Promise<AxiosUtilsResponse<string>>;

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

@@ -0,0 +1,15 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import httpZauru from "./httpZauru.server.js";
+/**
+ *
+ * @param headers
+ * @returns
+ */
+export const getReceptionTemplate = async (headers, id) => {
+    return handlePossibleAxiosErrors(async () => {
+        const response = await httpZauru.get(`/settings/templates/print_templates/${id}/preview_with_vars`, {
+            headers,
+        });
+        return response.data;
+    });
+};

package/dist/zauru/zauru-web-app-tables.server.d.ts

@@ -0,0 +1,48 @@
+import type { Session } from "@remix-run/node";
+import { AxiosUtilsResponse, WebAppRowGraphQL, WebAppTableCreateBody, WebAppTableGraphQL, WebAppTableUpdateResponse } from "@zauru-sdk/types";
+/**
+ * getWebAppRow
+ * @param headers
+ * @returns
+ */
+export declare function getWebAppRow<T>(session: Session, id: number): Promise<AxiosUtilsResponse<T>>;
+/**
+ * getWebAppTableRegisters Function for get all web app table registers
+ * @param headers
+ * @param webapp_table_id web app table id
+ * @returns
+ */
+export declare function getWebAppTableRegisters<T>(session: Session, webapp_table_id: string): Promise<AxiosUtilsResponse<WebAppRowGraphQL<T>[]>>;
+/**
+ * deleteWebAppTableRegister Function for delete a web app table register
+ * @param headers
+ * @param id_web_app_table
+ * @param id_register
+ * @returns
+ */
+export declare function deleteWebAppTableRegister(headers: any, id_web_app_table: string, id_register: number): Promise<WebAppTableUpdateResponse>;
+/**
+ * createWebAppTableRegister function for create a new web app table register
+ * @param headers
+ * @param body
+ * @param id_web_app_table
+ * @returns
+ */
+export declare function createWebAppTableRegister<T>(headers: any, id_web_app_table: string, body: T, extraBody?: {
+    temp_purchase_order_id: string;
+}): Promise<WebAppTableUpdateResponse>;
+/**
+ * updateWebAppTableRegister Function for update a web app table register
+ * @param headers
+ * @param id_web_app_table
+ * @param id_register
+ * @returns
+ */
+export declare function updateWebAppTableRegister<T>(headers: any, id_web_app_table: string, id_register: number | string, body: Partial<T>): Promise<WebAppTableUpdateResponse>;
+/**
+ *
+ * @param headers
+ * @param body
+ * @returns
+ */
+export declare function createWebAppTable(headers: any, body: WebAppTableCreateBody): Promise<AxiosUtilsResponse<WebAppTableGraphQL>>;

package/dist/zauru/zauru-web-app-tables.server.js

@@ -0,0 +1,120 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getWebAppRowStringQuery, getWebAppRowsByWebAppTableIdStringQuery, } from "@zauru-sdk/graphql";
+import httpZauru from "./httpZauru.server.js";
+/**
+ * getWebAppRow
+ * @param headers
+ * @returns
+ */
+export async function getWebAppRow(session, id) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getWebAppRowStringQuery,
+            variables: {
+                id,
+            },
+        }, { headers });
+        return response.data?.data?.webapp_rows[0]?.data;
+    });
+}
+/**
+ * getWebAppTableRegisters Function for get all web app table registers
+ * @param headers
+ * @param webapp_table_id web app table id
+ * @returns
+ */
+export async function getWebAppTableRegisters(session, webapp_table_id) {
+    return handlePossibleAxiosErrors(async () => {
+        const headers = await getGraphQLAPIHeaders(session);
+        const response = await httpGraphQLAPI.post("", {
+            query: getWebAppRowsByWebAppTableIdStringQuery,
+            variables: {
+                webapp_table_id,
+            },
+        }, { headers });
+        if (response.data.errors) {
+            throw new Error(response.data.errors.map((x) => x.message).join(";"));
+        }
+        if (!response?.data?.data.webapp_rows) {
+            return [];
+        }
+        return response.data?.data?.webapp_rows;
+    });
+}
+/**
+ * deleteWebAppTableRegister Function for delete a web app table register
+ * @param headers
+ * @param id_web_app_table
+ * @param id_register
+ * @returns
+ */
+export async function deleteWebAppTableRegister(headers, id_web_app_table, id_register) {
+    const response = await httpZauru(`/apps/webapp_tables/${id_web_app_table}/webapp_rows/${id_register}.json`, {
+        method: "DELETE",
+        headers: headers,
+    });
+    return response.data;
+}
+/**
+ * createWebAppTableRegister function for create a new web app table register
+ * @param headers
+ * @param body
+ * @param id_web_app_table
+ * @returns
+ */
+export async function createWebAppTableRegister(headers, id_web_app_table, body, extraBody) {
+    const requestBody = {
+        webapp_row: { data: body },
+        ...(extraBody ?? {}),
+    };
+    const response = await httpZauru(`/apps/webapp_tables/${id_web_app_table}/webapp_rows.json`, {
+        method: "POST",
+        headers: headers,
+        data: requestBody,
+    });
+    return response.data;
+}
+/**
+ * updateWebAppTableRegister Function for update a web app table register
+ * @param headers
+ * @param id_web_app_table
+ * @param id_register
+ * @returns
+ */
+export async function updateWebAppTableRegister(headers, id_web_app_table, id_register, body) {
+    const requestBody = { webapp_row: { data: body } };
+    const response = await httpZauru(`/apps/webapp_tables/${id_web_app_table}/webapp_rows/${id_register}.json`, {
+        method: "PATCH",
+        headers: headers,
+        data: requestBody,
+    });
+    return response.data;
+}
+//============================== WEB APP TABLE
+/**
+ *
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createWebAppTable(headers, body) {
+    try {
+        const response = await httpZauru.post(`/apps/webapp_tables.json`, { webapp_table: body }, {
+            headers,
+        });
+        return {
+            data: response.data,
+            error: false,
+        };
+    }
+    catch (error) {
+        return {
+            msg: error,
+            error: true,
+            userMsg: `Ocurrió un error al intentar crear la web app table ${body.name}`,
+        };
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zauru-sdk/services",
-  "version": "1.0.6",
-  "description": "Configuración centralizada para aplicaciones Zauru SDK",
+  "version": "1.0.8",
+  "description": "Servicios de consulta a Zauru",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -19,15 +19,15 @@
   },
   "dependencies": {
     "@remix-run/node": "^2.8.1",
-    "@zauru-sdk/common": "^1.0.6",
+    "@zauru-sdk/common": "^1.0.8",
     "@zauru-sdk/config": "^1.0.4",
-    "@zauru-sdk/graphql": "^1.0.5",
-    "@zauru-sdk/types": "^1.0.6",
+    "@zauru-sdk/graphql": "^1.0.7",
+    "@zauru-sdk/types": "^1.0.8",
     "axios": "^1.6.7",
     "chalk": "5.3.0"
   },
   "engines": {
     "node": ">=18.0.0"
   },
-  "gitHead": "d49d7b1cec4ab5685b34983c46d97db129115aaf"
+  "gitHead": "60fc0a94174a359d300c7479bcb8278316857ed9"
 }

package/src/index.ts

@@ -9,5 +9,28 @@ export * from "./zauru/httpZauru.server.js";
 
 export * from "./zauru/zauru-agencies.server.js";
 export * from "./zauru/zauru-automatic-numbers.server.js";
+export * from "./zauru/zauru-bookings.server.js";
+export * from "./zauru/zauru-bundles.service.js";
+export * from "./zauru/zauru-cases.server.js";
+export * from "./zauru/zauru-consolidated.server.js";
+export * from "./zauru/zauru-deliveries.server.js";
+export * from "./zauru/zauru-discharges.server.js";
+export * from "./zauru/zauru-employees.server.js";
+export * from "./zauru/zauru-forms.server.js";
+export * from "./zauru/zauru-invoices.server.js";
+export * from "./zauru/zauru-items.server.js";
+export * from "./zauru/zauru-lote-record.server.js";
+export * from "./zauru/zauru-lotes.server.js";
+export * from "./zauru/zauru-motivos-rechazo.server.js";
+export * from "./zauru/zauru-payees.server.js";
+export * from "./zauru/zauru-payment-terms.server.js";
+export * from "./zauru/zauru-price-lists.server.js";
+export * from "./zauru/zauru-purchase-orders.server.js";
 export * from "./zauru/zauru-profiles.server.js";
+export * from "./zauru/zauru-receptions.server.js";
+export * from "./zauru/zauru-shipments.server.js";
+export * from "./zauru/zauru-suggested-prices.server.js";
+export * from "./zauru/zauru-tags.server.js";
+export * from "./zauru/zauru-templates.server.js";
+export * from "./zauru/zauru-web-app-tables.server.js";
 export * from "./zauru/zauru-variables.server.js";

package/src/zauru/zauru-bookings.server.ts

@@ -0,0 +1,134 @@
+import { arrayToObject, handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import {
+  AxiosUtilsResponse,
+  InsertBookingBody,
+  ShipmentGraphQL,
+} from "@zauru-sdk/types";
+import httpZauru from "./httpZauru.server.js";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import { Session } from "@remix-run/node";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getShipmentsStringQuery } from "@zauru-sdk/graphql";
+
+/**
+ * insertBookings
+ * @param headers
+ * @param body
+ * @returns
+ */
+export const insertBookings = async (
+  headers: any,
+  body: Partial<InsertBookingBody>,
+  temp_purchase_order_id?: string
+): Promise<AxiosUtilsResponse<ShipmentGraphQL>> => {
+  return handlePossibleAxiosErrors(async () => {
+    const sendBody: any = {
+      shipment: {
+        ...body,
+        movements_attributes: arrayToObject(body.movements),
+      },
+    };
+
+    delete sendBody.shipment.movements;
+
+    if (temp_purchase_order_id) {
+      sendBody[`temp_purchase_order_id`] = `${temp_purchase_order_id}`;
+    }
+
+    const response = await httpZauru.post<ShipmentGraphQL>(
+      `/inventories/bookings.json`,
+      sendBody,
+      {
+        headers,
+      }
+    );
+
+    return response.data;
+  });
+};
+
+/**
+ * getDeliveryByBooking
+ * @param headers
+ * @param shipment_id
+ * @returns
+ */
+export const getDeliveryByBooking = async (
+  headers: any,
+  shipment_id: number
+) => {
+  return handlePossibleAxiosErrors(async () => {
+    if (!shipment_id) {
+      throw new Error("No hay un shipment_id, en getDeliveryByBooking");
+    }
+
+    const response = await httpZauru.get<any>(
+      `/inventories/bookings/${shipment_id}/deliver.json`,
+      {
+        headers,
+        data: {
+          id: shipment_id,
+        },
+      }
+    );
+
+    return response.data;
+  });
+};
+
+/**
+ * getBookings
+ * @param headers
+ * @returns
+ */
+export const getBookings = async (
+  session: Session,
+  wheres: string[] = []
+): Promise<AxiosUtilsResponse<ShipmentGraphQL[]>> => {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { shipments: ShipmentGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getShipmentsStringQuery([...wheres, "delivered: {_eq: false}"]),
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    const registers = response?.data?.data?.shipments;
+
+    return registers;
+  });
+};
+
+/**
+ * getBookings
+ * @param headers
+ * @returns
+ */
+export const getBooking = async (
+  headers: any,
+  booking_id: string
+): Promise<AxiosUtilsResponse<ShipmentGraphQL>> => {
+  return handlePossibleAxiosErrors(async () => {
+    const response = await httpZauru.get<any>(
+      `/inventories/bookings/${booking_id}.json`,
+      {
+        headers,
+      }
+    );
+
+    return response.data;
+  });
+};

package/src/zauru/zauru-bundles.service.ts

@@ -0,0 +1,157 @@
+import type { Session } from "@remix-run/node";
+import { arrayToObject, handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { AxiosUtilsResponse, BundleGraphQL } from "@zauru-sdk/types";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import {
+  getBundleByNameStringQuery,
+  getBundlesByItemCategoryIdStringQuery,
+} from "@zauru-sdk/graphql";
+import httpZauru from "./httpZauru.server.js";
+
+/**
+ * getBundlesByItemCategoryId
+ */
+export async function getBundlesByItemCategoryId(
+  session: Session,
+  id: string
+): Promise<AxiosUtilsResponse<BundleGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { bundles: BundleGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getBundlesByItemCategoryIdStringQuery,
+        variables: {
+          id,
+        },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    const registers = response?.data?.data?.bundles;
+
+    return registers;
+  });
+}
+
+/**
+ * getBundleByName
+ */
+export async function getBundleByName(
+  session: Session,
+  name: string
+): Promise<AxiosUtilsResponse<BundleGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { bundles: BundleGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getBundleByNameStringQuery,
+        variables: {
+          name,
+        },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    if (!response?.data?.data?.bundles[0]) {
+      throw new Error(
+        `No se encontró ningún bundle con el nombre: ${name} asociado`
+      );
+    }
+
+    const register = response?.data?.data?.bundles[0];
+
+    return register;
+  });
+}
+
+/**
+ * createBundle
+ * @param headers
+ * @param body
+ */
+export async function createBundle(
+  headers: any,
+  body: Partial<BundleGraphQL>
+): Promise<AxiosUtilsResponse<BundleGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const sendBody = {
+      ...body,
+      bundle_details_attributes: arrayToObject(body.bundle_details, {
+        withOutId: true,
+      }),
+    };
+    delete sendBody.bundle_details;
+    const response = await httpZauru.post<BundleGraphQL>(
+      `/inventories/bundles.json`,
+      sendBody,
+      { headers }
+    );
+    return response.data;
+  });
+}
+
+/**
+ * updateBundle
+ * @param headers
+ * @param body
+ */
+export async function updateBundle(
+  headers: any,
+  body: Partial<BundleGraphQL>
+): Promise<AxiosUtilsResponse<BundleGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const sendBody = {
+      ...body,
+      bundle_details_attributes: arrayToObject(body.bundle_details),
+    };
+    delete sendBody.bundle_details;
+    const response = await httpZauru.patch<BundleGraphQL>(
+      `/inventories/bundles/${body.id}.json`,
+      sendBody,
+      { headers }
+    );
+    return response.data;
+  });
+}
+
+/**
+ * deleteBundle
+ * @param headers
+ * @param body
+ */
+export async function deleteBundle(
+  headers: any,
+  id: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.delete<any>(`/inventories/bundles/${id}?destroy=true`, {
+      headers,
+    });
+    return true;
+  });
+}

package/src/zauru/zauru-cases.server.ts

@@ -0,0 +1,44 @@
+import type { Session } from "@remix-run/node";
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { AxiosUtilsResponse, CaseGraphQL } from "@zauru-sdk/types";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import { getCasesByResponsibleIdStringQuery } from "@zauru-sdk/graphql";
+
+/**
+ * getCasesByResponsibleId
+ */
+export async function getCasesByResponsibleId(
+  session: Session,
+  responsible_id: string,
+  wheres: string[] = []
+): Promise<AxiosUtilsResponse<CaseGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { cases: CaseGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getCasesByResponsibleIdStringQuery(wheres),
+        variables: {
+          responsible_id,
+        },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    const registers = response?.data?.data?.cases;
+
+    return registers;
+  });
+}