@zauru-sdk/services 1.0.6 → 1.0.7

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

@@ -0,0 +1,142 @@
+import type { Session } from "@remix-run/node";
+import { arrayToObject, handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import {
+  AxiosUtilsResponse,
+  InvoiceGraphQL,
+  SubmissionInvoicesGraphQL,
+} from "@zauru-sdk/types";
+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: Session,
+  id: string | null
+): Promise<AxiosUtilsResponse<InvoiceGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { invoices: InvoiceGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        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;
+      }, {} as { [key: string]: SubmissionInvoicesGraphQL });
+
+      x.submission_invoices = Object.values(groupedByVersion)?.reverse() ?? [];
+
+      return x;
+    });
+
+    return registers;
+  });
+}
+
+/**
+ * createInvoiceOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createInvoiceOrder(
+  headers: any,
+  body: Partial<InvoiceGraphQL>
+): Promise<AxiosUtilsResponse<InvoiceGraphQL>> {
+  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) ?? [],
+    } as any;
+
+    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<InvoiceGraphQL>(
+      `/sales/orders.json`,
+      { invoice: sendBody },
+      { headers }
+    );
+
+    return response.data;
+  });
+}
+
+/**
+ * updateInvoiceOrder
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function updateInvoiceOrder(
+  headers: any,
+  body: Partial<InvoiceGraphQL>
+): Promise<AxiosUtilsResponse<InvoiceGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const sendBody = {
+      ...body,
+      invoice_details_attributes: arrayToObject(body.invoice_details),
+    } as any;
+    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<InvoiceGraphQL>(
+      `/sales/orders/${body.id}.json`,
+      { invoice: sendBody },
+      { headers }
+    );
+
+    return response.data;
+  });
+}
+
+/**
+ * deleteInvoice
+ * @param headers
+ * @param body
+ */
+export async function deleteInvoiceOrder(
+  headers: any,
+  id: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.get<any>(`/sales/orders/${id}/void`, {
+      headers,
+    });
+    return true;
+  });
+}

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

@@ -0,0 +1,427 @@
+import type { Session } from "@remix-run/node";
+import { handlePossibleAxiosErrors } from "@zauru-sdk/common";
+import {
+  AxiosUtilsResponse,
+  ItemCategoryGraphQL,
+  ItemGraphQL,
+  ItemSuperCategoryGraphQL,
+} from "@zauru-sdk/types";
+import { getGraphQLAPIHeaders } from "~/common.server.js";
+import httpGraphQLAPI from "./httpGraphQL.server.js";
+import {
+  getItemByNameStringQuery,
+  getItemCategoryByIdStringQuery,
+  getItemsByCategoryStringQuery,
+  getItemsBySuperCategoryStringQuery,
+  getItemsStringQuery,
+  getSuperCategoryByIdStringQuery,
+} from "@zauru-sdk/graphql";
+import httpZauru from "./httpZauru.server.js";
+
+/**
+ * getItems
+ */
+export async function getItems(
+  session: Session
+): Promise<AxiosUtilsResponse<ItemGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { items: ItemGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getItemsStringQuery,
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    const items = response?.data?.data?.items ?? [];
+
+    return items;
+  });
+}
+
+/**
+ * getItemByName
+ */
+export async function getItemByName(
+  session: Session,
+  name: string
+): Promise<AxiosUtilsResponse<ItemGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { items: ItemGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getItemByNameStringQuery,
+        variables: {
+          name,
+        },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    if (!response?.data?.data?.items[0]) {
+      throw new Error(
+        `No se encontró ningún item con el nombre: ${name} asociado`
+      );
+    }
+
+    const register = response?.data?.data?.items[0];
+
+    return register;
+  });
+}
+
+//===================== ITEM CATEGORIES
+
+/**
+ * getItemCategories
+ * @param headers
+ * @param agency_id
+ * @returns
+ */
+export async function getItemCategories(
+  headers: any,
+  item_category_id: string
+): Promise<ItemCategoryGraphQL> {
+  const response = await httpZauru.get<ItemCategoryGraphQL>(
+    `/settings/items/item_categories/${item_category_id}.json`,
+    {
+      headers,
+    }
+  );
+
+  return response.data;
+}
+
+/**
+ * getItemsByCategoryId
+ */
+export async function getItemsByCategoryId(
+  session: Session,
+  id: string
+): Promise<AxiosUtilsResponse<ItemGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { item_categories: ItemCategoryGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getItemsByCategoryStringQuery,
+        variables: {
+          id,
+        },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    if (!response?.data?.data?.item_categories[0]) {
+      throw new Error("No se encontró la categoría de item indicada");
+    }
+
+    const items = response?.data?.data?.item_categories[0]?.items ?? [];
+
+    return items;
+  });
+}
+
+/**
+ * getItemCategory
+ * @param session
+ * @param id
+ */
+export async function getItemCategory(
+  session: Session,
+  id: number | string
+): Promise<AxiosUtilsResponse<ItemCategoryGraphQL | undefined>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+
+    const response = await httpGraphQLAPI.post<{
+      data: { item_categories: ItemCategoryGraphQL[] };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      "",
+      {
+        query: getItemCategoryByIdStringQuery,
+        variables: {
+          id,
+        },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    if (!response?.data?.data?.item_categories[0]) {
+      throw new Error("No se encontró la categoría de item indicada");
+    }
+
+    return response?.data?.data?.item_categories[0];
+  });
+}
+
+/**
+ * getItemCategoriesBySuperCategoryId
+ * @param session
+ * @param categoryId
+ * @returns
+ */
+export async function getItemCategoriesBySuperCategoryId(
+  session: Session,
+  id: number | string
+): Promise<AxiosUtilsResponse<ItemCategoryGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+    const response = await httpGraphQLAPI.post<{
+      data: {
+        item_super_categories: ItemSuperCategoryGraphQL[];
+      };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      ``,
+      {
+        query: getSuperCategoryByIdStringQuery,
+        variables: { id },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    if (!response?.data?.data.item_super_categories[0].item_categories) {
+      return [];
+    }
+
+    return response.data?.data.item_super_categories[0]?.item_categories;
+  });
+}
+
+/**
+ * getItemsBySuperCategoryId
+ * @param session
+ * @param categoryId
+ * @returns
+ */
+export async function getItemsBySuperCategoryId(
+  session: Session,
+  id: number | string,
+  agency_id: number | string
+): Promise<AxiosUtilsResponse<ItemGraphQL[]>> {
+  return handlePossibleAxiosErrors(async () => {
+    const headers = await getGraphQLAPIHeaders(session);
+    const response = await httpGraphQLAPI.post<{
+      data: {
+        item_super_categories: ItemSuperCategoryGraphQL[];
+      };
+      errors?: {
+        message: string;
+        extensions: { path: string; code: string };
+      }[];
+    }>(
+      ``,
+      {
+        query: getItemsBySuperCategoryStringQuery,
+        variables: { id, agency_id },
+      },
+      { headers }
+    );
+
+    if (response.data.errors) {
+      throw new Error(response.data.errors.map((x) => x.message).join(";"));
+    }
+
+    if (!response?.data?.data.item_super_categories[0].item_categories) {
+      return [];
+    }
+
+    const items: ItemGraphQL[] = [];
+
+    response.data?.data.item_super_categories[0]?.item_categories.forEach((x) =>
+      items.push(...x.items)
+    );
+
+    return items;
+  });
+}
+
+/**
+ * createItemSuperCategory
+ * @param session
+ * @param headers
+ * @returns
+ */
+export async function createItemSuperCategory(
+  headers: any,
+  body: Partial<ItemSuperCategoryGraphQL>
+): Promise<AxiosUtilsResponse<ItemSuperCategoryGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const response = await httpZauru.post<ItemSuperCategoryGraphQL>(
+      "/settings/items/item_super_categories.json",
+      { item_super_category: body },
+      { headers }
+    );
+    return response.data;
+  });
+}
+
+/**
+ * createItemCategory
+ * @param session
+ * @param headers
+ * @returns
+ */
+export async function createItemCategory(
+  headers: any,
+  body: Partial<ItemCategoryGraphQL>
+): Promise<AxiosUtilsResponse<ItemCategoryGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const itemCategoryResponse = await httpZauru.post<ItemCategoryGraphQL>(
+      "/settings/items/item_categories",
+      { item_category: body },
+      { headers }
+    );
+    return itemCategoryResponse.data;
+  });
+}
+
+/**
+ * deleteItemCategory
+ * @param headers
+ * @param id
+ * @returns
+ */
+export async function deleteItemCategory(
+  headers: any,
+  id: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.delete<any>(
+      `/settings/items/item_categories/${id}?destroy=true`,
+      {
+        headers,
+      }
+    );
+    return true;
+  });
+}
+
+/**
+ * updatePayee
+ * @param session
+ * @param headers
+ * @returns
+ */
+export async function updateItemCategory(
+  headers: any,
+  body: Partial<ItemCategoryGraphQL>
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.patch<any>(
+      `/settings/items/item_categories/${body.id}`,
+      { item_category: body },
+      { headers }
+    );
+    return true;
+  });
+}
+
+/**
+ * createItem
+ * @param headers
+ * @param body
+ * @returns
+ */
+export async function createItem(
+  headers: any,
+  body: Partial<ItemGraphQL>
+): Promise<AxiosUtilsResponse<ItemGraphQL>> {
+  return handlePossibleAxiosErrors(async () => {
+    const response = await httpZauru.post<ItemGraphQL>(
+      `/settings/items.json`,
+      { item: body },
+      { headers }
+    );
+    return response.data;
+  });
+}
+
+/**
+ * updateItem
+ * @param headers
+ * @param body
+ * @param id
+ * @returns
+ */
+export async function updateItem(headers: any, body: Partial<ItemGraphQL>) {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.patch<Partial<ItemGraphQL>>(
+      `/settings/items/${body.id}.json`,
+      body,
+      {
+        headers,
+      }
+    );
+    return true;
+  });
+}
+
+/**
+ * deleteItemCategory
+ * @param headers
+ * @param id
+ * @returns
+ */
+export async function deleteItem(
+  headers: any,
+  id: string | number
+): Promise<AxiosUtilsResponse<boolean>> {
+  return handlePossibleAxiosErrors(async () => {
+    await httpZauru.delete<any>(`/settings/items/${id}?destroy=true`, {
+      headers,
+    });
+    return true;
+  });
+}

package/src/zauru/zauru-lote-record.server.ts

@@ -0,0 +1,77 @@
+import type { Session } from "@remix-run/node";
+import { LoteRecordBody, WebAppRowGraphQL } from "@zauru-sdk/types";
+import { getVariablesByName } from "~/common.server.js";
+import {
+  createWebAppTableRegister,
+  deleteWebAppTableRegister,
+  getWebAppTableRegisters,
+} from "./zauru-web-app-tables.server.js";
+
+export async function getLoteRecord(
+  headers: any,
+  session: Session
+): Promise<WebAppRowGraphQL<LoteRecordBody>[]> {
+  const { lote_record_webapp_table_id: webapp_table_id } =
+    await getVariablesByName(headers, session, ["lote_record_webapp_table_id"]);
+
+  const response = await getWebAppTableRegisters<LoteRecordBody>(
+    session,
+    webapp_table_id
+  );
+
+  if (response.error) {
+    throw new Error(`Error al obtener el lote: ${response.userMsg}`);
+  }
+
+  const lotes = response.data ?? [];
+
+  return lotes;
+}
+
+export async function deleteLoteRecord(
+  headers: any,
+  session: Session,
+  id: number
+): Promise<any> {
+  const { lote_record_webapp_table_id: webapp_table_id } =
+    await getVariablesByName(headers, session, ["lote_record_webapp_table_id"]);
+
+  const response = await deleteWebAppTableRegister(
+    headers,
+    webapp_table_id,
+    id
+  );
+  return response.data;
+}
+
+export async function createLoteRecord(
+  headers: any,
+  session: Session,
+  body: LoteRecordBody
+) {
+  const { lote_record_webapp_table_id: webapp_table_id } =
+    await getVariablesByName(headers, session, ["lote_record_webapp_table_id"]);
+
+  const response = await createWebAppTableRegister<LoteRecordBody>(
+    headers,
+    webapp_table_id,
+    body
+  );
+  return response.data;
+}
+
+export async function updateLoteRecord(
+  headers: any,
+  session: Session,
+  id: number
+): Promise<any> {
+  const { lote_record_webapp_table_id: webapp_table_id } =
+    await getVariablesByName(headers, session, ["lote_record_webapp_table_id"]);
+
+  const response = await deleteWebAppTableRegister(
+    headers,
+    webapp_table_id,
+    id
+  );
+  return response.data;
+}