@zauru-sdk/services 1.0.6 → 1.0.7

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

@@ -0,0 +1,148 @@
+import type { Session } from "@remix-run/node";
+import {
+  arrayToObject,
+  getDatePickerCurrentDate,
+  handlePossibleAxiosErrors,
+} from "@zauru-sdk/common";
+import {
+  AxiosUtilsResponse,
+  NewReceptionBody,
+  PurchaseOrderGraphQL,
+} from "@zauru-sdk/types";
+import httpZauru from "./httpZauru.server.js";
+
+/**
+ * createNewReception
+ * @param headers
+ * @param body
+ * @param purchase_order_id
+ * @returns
+ */
+export async function createNewReception(
+  headers: any,
+  body: NewReceptionBody,
+  purchase_order_id: number | string
+) {
+  return handlePossibleAxiosErrors(async () => {
+    const response = await httpZauru<any>(
+      `/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: any,
+  receptionId: string | number,
+  poId: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  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: any,
+  session: Session,
+  body: Partial<PurchaseOrderGraphQL>
+): Promise<AxiosUtilsResponse<boolean>> {
+  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: any,
+  session: Session,
+  body: Partial<PurchaseOrderGraphQL> & { fechaVencimiento: string }
+): Promise<AxiosUtilsResponse<boolean>> {
+  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/src/zauru/zauru-shipments.server.ts

@@ -0,0 +1,88 @@
+import type { Session } from "@remix-run/node";
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import { AxiosUtilsResponse, ShipmentGraphQL } from "@zauru-sdk/types";
+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: Session,
+  agency_to_id: string | number
+): 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: 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: any,
+  id: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    const response = await httpZauru.get<any>(
+      `/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: any,
+  id: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.delete<any>(`/inventories/bookings/${id}.json`, {
+      headers,
+    });
+    return true;
+  });
+}

package/src/zauru/zauru-suggested-prices.server.ts

@@ -0,0 +1,134 @@
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import {
+  AxiosUtilsResponse,
+  ItemWithPrices,
+  SuggestedPriceGraphQL,
+} from "@zauru-sdk/types";
+import httpZauru from "./httpZauru.server.js";
+import { Session } from "@remix-run/node";
+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: any
+): Promise<AxiosUtilsResponse<ItemWithPrices[]>> => {
+  return handlePossibleAxiosErrors(async () => {
+    const response = await httpZauru.get<ItemWithPrices[]>(
+      `/sales/suggested_prices/export.json`,
+      {
+        headers,
+      }
+    );
+
+    return response.data;
+  });
+};
+
+/**
+ * getSuggestedPrices
+ * @param session
+ * @param id
+ */
+export async function getSuggestedPrices(
+  session: Session,
+  config: {
+    notNullPriceList?: boolean;
+    withItems?: boolean;
+    withItemCategories?: boolean;
+  }
+): Promise<AxiosUtilsResponse<SuggestedPriceGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const {
+      notNullPriceList = false,
+      withItems = false,
+      withItemCategories = false,
+    } = config;
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { suggested_prices: SuggestedPriceGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        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: any,
+  body: Partial<SuggestedPriceGraphQL>
+): Promise<AxiosUtilsResponse<SuggestedPriceGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const response = await httpZauru.post<SuggestedPriceGraphQL>(
+      `/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: any,
+  id: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.delete<any>(`/sales/suggested_prices/${id}?destroy=true`, {
+      headers,
+    });
+    return true;
+  });
+}

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

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

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

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

package/src/zauru/zauru-web-app-tables.server.ts

@@ -0,0 +1,200 @@
+import type { Session } from "@remix-run/node";
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import {
+  AxiosUtilsResponse,
+  WebAppRowGraphQL,
+  WebAppTableBody,
+  WebAppTableCreateBody,
+  WebAppTableGraphQL,
+  WebAppTableUpdateResponse,
+} from "@zauru-sdk/types";
+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<T>(
+  session: Session,
+  id: number
+): Promise<AxiosUtilsResponse<T>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { webapp_rows: WebAppRowGraphQL<T>[] };
+    }>(
+      "",
+      {
+        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<T>(
+  session: Session,
+  webapp_table_id: string
+): Promise<AxiosUtilsResponse<WebAppRowGraphQL<T>[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { webapp_rows: WebAppRowGraphQL<T>[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        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: any,
+  id_web_app_table: string,
+  id_register: number
+): Promise<WebAppTableUpdateResponse> {
+  const response = await httpZauru<WebAppTableUpdateResponse>(
+    `/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<T>(
+  headers: any,
+  id_web_app_table: string,
+  body: T,
+  extraBody?: { temp_purchase_order_id: string }
+): Promise<WebAppTableUpdateResponse> {
+  const requestBody = {
+    webapp_row: { data: body },
+    ...(extraBody ?? {}),
+  } as WebAppTableBody<T>;
+  const response = await httpZauru<WebAppTableUpdateResponse>(
+    `/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<T>(
+  headers: any,
+  id_web_app_table: string,
+  id_register: number | string,
+  body: Partial<T>
+): Promise<WebAppTableUpdateResponse> {
+  const requestBody = { webapp_row: { data: body } } as WebAppTableBody<T>;
+  const response = await httpZauru<WebAppTableUpdateResponse>(
+    `/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: any,
+  body: WebAppTableCreateBody
+) {
+  try {
+    const response = await httpZauru.post<WebAppTableGraphQL>(
+      `/apps/webapp_tables.json`,
+      { webapp_table: body },
+      {
+        headers,
+      }
+    );
+
+    return {
+      data: response.data,
+      error: false,
+    } as AxiosUtilsResponse<WebAppTableGraphQL>;
+  } catch (error) {
+    return {
+      msg: error,
+      error: true,
+      userMsg: `Ocurrió un error al intentar crear la web app table ${body.name}`,
+    } as AxiosUtilsResponse<WebAppTableGraphQL>;
+  }
+}