@zauru-sdk/redux 1.0.10

package/dist/store.js

@@ -0,0 +1,125 @@
+import { Tuple, configureStore } from "@reduxjs/toolkit";
+import catalogsReducer from "./slices/catalogs.slice.js";
+import profilesReducer from "./slices/profile.slice.js";
+import webappTablesReducer from "./slices/webapp-tables.slice.js";
+import receptionsReducer from "./slices/reception.slice.js";
+import sessionReducer from "./slices/session.slice.js";
+import templateReducer from "./slices/templates.slice.js";
+import automaticNumberReducer from "./slices/automaticNumbers.slice.js";
+import tableReducer from "./slices/tables.slice.js";
+import formValidationReducer from "./slices/formValidation.slice.js";
+export const LOCAL_STORAGE_REDUX_NAME = "___redux__state__v2";
+const persistanceLocalStorageMiddleware = (store) => (next) => (action) => {
+    const result = next(action);
+    if (!(typeof document === "undefined")) {
+        localStorage.setItem(LOCAL_STORAGE_REDUX_NAME, JSON.stringify(store.getState()));
+    }
+    return result;
+};
+const preloadedState = (() => {
+    try {
+        if (!(typeof document === "undefined")) {
+            const savedState = localStorage.getItem(LOCAL_STORAGE_REDUX_NAME);
+            if (savedState) {
+                return JSON.parse(savedState);
+            }
+        }
+    }
+    catch (e) {
+        // Ignorar los errores, se utiliza el estado inicial definido en cada reducer
+    }
+})();
+export const cleanLocalStorage = () => {
+    const savedState = localStorage.getItem(LOCAL_STORAGE_REDUX_NAME);
+    const state = JSON.parse(savedState ?? "{}");
+    try {
+        //delete all cookies
+        // const deleteAllCookies = () => {
+        //   const cookies = document.cookie.split(";");
+        //   for (const cookie of cookies) {
+        //     const eqPos = cookie.indexOf("=");
+        //     const name = eqPos > -1 ? cookie.substring(0, eqPos) : cookie;
+        //     document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+        //   }
+        // };
+        // deleteAllCookies();
+        // //delete caché
+        // caches.keys().then((names) => {
+        //   for (const name of names) {
+        //     caches.delete(name);
+        //   }
+        // });
+        //unregister service workers
+        // navigator.serviceWorker.getRegistrations().then((registrations) => {
+        //   for (const registration of registrations) {
+        //     registration.unregister();
+        //   }
+        // });
+        // Limpiar todo el localStorage
+        localStorage.clear();
+    }
+    catch (error) {
+        console.error(error);
+    }
+    try {
+        const whitelist = {
+            automaticNumbers: ["purchaseOrderIdNumber", "dischargeIdNumber"],
+            receptions: ["queueNewReceptions"],
+        };
+        if (!(typeof document === "undefined") && Object.keys(state)?.length > 0) {
+            const initialState = {
+                catalogs: catalogsReducer(undefined, { type: "" }),
+                profiles: profilesReducer(undefined, { type: "" }),
+                webappTables: webappTablesReducer(undefined, { type: "" }),
+                receptions: receptionsReducer(undefined, { type: "" }),
+                session: sessionReducer(undefined, { type: "" }),
+                templates: templateReducer(undefined, { type: "" }),
+                automaticNumbers: automaticNumberReducer(undefined, { type: "" }),
+                tables: tableReducer(undefined, { type: "" }),
+                formValidation: formValidationReducer(undefined, { type: "" }),
+            };
+            const newState = { ...initialState };
+            for (const reducerName in whitelist) {
+                if (state.hasOwnProperty(reducerName)) {
+                    const key = reducerName;
+                    const reducerState = state[key];
+                    const whitelistKey = whitelist[key];
+                    if (whitelistKey && whitelistKey.length > 0) {
+                        newState[key] = newState[key] ? { ...newState[key] } : {};
+                        for (const propertyName of whitelistKey) {
+                            if (reducerState?.hasOwnProperty(propertyName)) {
+                                const propKey = propertyName;
+                                if (newState[key] && reducerState) {
+                                    newState[key][propKey] = reducerState[propKey];
+                                }
+                            }
+                        }
+                    }
+                    else if (reducerState) {
+                        newState[key] = reducerState;
+                    }
+                }
+            }
+            // Guarda el nuevo estado en el almacenamiento local
+            localStorage.setItem(LOCAL_STORAGE_REDUX_NAME, JSON.stringify(newState));
+        }
+    }
+    catch (e) {
+        console.error("Ocurrió un error al clonar y eliminar el viejo localStorage");
+    }
+};
+export const store = configureStore({
+    reducer: {
+        catalogs: catalogsReducer,
+        profiles: profilesReducer,
+        webappTables: webappTablesReducer,
+        receptions: receptionsReducer,
+        session: sessionReducer,
+        templates: templateReducer,
+        automaticNumbers: automaticNumberReducer,
+        tables: tableReducer,
+        formValidation: formValidationReducer,
+    },
+    preloadedState,
+    middleware: (getDefaultMiddleware) => new Tuple(persistanceLocalStorageMiddleware),
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@zauru-sdk/redux",
+  "version": "1.0.10",
+  "description": "Estructura de Redux propuesta para el desarrollo de webapps en Zauru.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Oscar Cuéllar",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@reduxjs/toolkit": "^2.2.1",
+    "@zauru-sdk/graphql": "^1.0.9",
+    "@zauru-sdk/services": "^1.0.10",
+    "@zauru-sdk/types": "^1.0.10",
+    "@zauru-sdk/utils": "^1.0.10"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "gitHead": "92bcefbeded758ac406e0436dc5c1894390a319d"
+}

package/src/slices/agency.slice.ts

@@ -0,0 +1,32 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+import { AgencyGraphQL } from "@zauru-sdk/types";
+
+export interface AgencyState {
+  agencyProfile: AgencyGraphQL;
+  loadingAgencyProfile: boolean;
+}
+
+const initialState: AgencyState = {
+  agencyProfile: {} as AgencyGraphQL,
+  loadingAgencyProfile: false,
+};
+
+const agencySlice = createSlice({
+  name: "agency",
+  initialState,
+  reducers: {
+    setAgencyProfile: (state, action: PayloadAction<AgencyGraphQL>) => {
+      state.agencyProfile = action.payload;
+    },
+    setLoadingAgencyProfile: (state, action: PayloadAction<boolean>) => {
+      state.loadingAgencyProfile = action.payload;
+      state.loadingAgencyProfile = false;
+    },
+  },
+});
+
+export const { setAgencyProfile, setLoadingAgencyProfile } =
+  agencySlice.actions;
+
+export default agencySlice.reducer;

package/src/slices/automaticNumbers.slice.ts

@@ -0,0 +1,41 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+
+export type AUTOMATIC_NUMBER_NAMES =
+  | "dischargeIdNumber"
+  | "purchaseOrderIdNumber";
+
+export interface AutomaticNumberState {
+  purchaseOrderIdNumber: { loading: boolean; data: number | string };
+  dischargeIdNumber: { loading: boolean; data: number | string };
+}
+
+const initialState: AutomaticNumberState = {
+  purchaseOrderIdNumber: { data: "", loading: false },
+  dischargeIdNumber: { data: "NCB00000", loading: false },
+};
+
+const automaticNumbersSlice = createSlice({
+  name: "automaticNumbers",
+  initialState,
+  reducers: {
+    automaticNumberFetchStart: (
+      state,
+      action: PayloadAction<AUTOMATIC_NUMBER_NAMES>
+    ) => {
+      state[action.payload].loading = true;
+    },
+    automaticNumberFetchSuccess: (
+      state,
+      action: PayloadAction<{ name: AUTOMATIC_NUMBER_NAMES; data: any }>
+    ) => {
+      state[action.payload.name].data = action.payload.data;
+      state[action.payload.name].loading = false;
+    },
+  },
+});
+
+export const { automaticNumberFetchStart, automaticNumberFetchSuccess } =
+  automaticNumbersSlice.actions;
+
+export default automaticNumbersSlice.reducer;

package/src/slices/catalogs.slice.ts

@@ -0,0 +1,178 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+import type {
+  AgencyGraphQL,
+  BitacoraPOMassive,
+  BundleGraphQL,
+  CaseGraphQL,
+  CurrencyGraphQL,
+  EmployeeGraphQL,
+  FormGraphQL,
+  FormSubmissionGraphQL,
+  InvoiceGraphQL,
+  ItemCategoryGraphQL,
+  ItemGraphQL,
+  LotStockGraphQL,
+  MotivoRechazo,
+  PayeeCategoryGraphQL,
+  PayeeGraphQL,
+  PaymentTermGraphQL,
+  ReceptionType,
+  ShipmentGraphQL,
+  SuggestedPriceGraphQL,
+  Template,
+  TipoMuestra,
+  WebAppRowGraphQL,
+} from "@zauru-sdk/types";
+
+export type ONLINE_CATALOGS_NAMES =
+  | "invoiceFormSubmissionsByInvoiceId"
+  | "invoiceFormSubmissionsByAgencyId";
+
+export type CATALOGS_NAMES =
+  | "agencies"
+  | "suggestedPrices"
+  | "providers"
+  | "providerCategories"
+  | "receptionTypes"
+  | "tiposDeMuestra"
+  | "motivosRechazo"
+  | "bitacoraRechazoMasivo"
+  | "items"
+  | "itemsByReception"
+  | "itemsByLab"
+  | "itemServicesByLab"
+  | "itemCategoriesForLab"
+  | "payees"
+  | "payeesForLab"
+  | "payeeCategoriesLabPrices"
+  | "clientCategories"
+  | "bundlesRecipForLab"
+  | "currencies"
+  | "paymentTerms"
+  | "employeesByLab"
+  | "employeesByCurrentAgency"
+  | "invoicesByLab"
+  | "invoiceForms"
+  | "caseForms"
+  | "invoiceFormSubmissions"
+  | "myCases"
+  | "myCaseFormSubmissions"
+  | "shipmentsToMyAgency"
+  | "myAgencyLotStocks"
+  | "shipments"
+  | "bookings"
+  | "templates"
+  | "bundlesForLab";
+
+type LoadingState<T> = {
+  data: T;
+  loading: boolean;
+  reFetch: boolean;
+};
+
+type CatalogState = {
+  agencies: LoadingState<AgencyGraphQL[]>;
+  suggestedPrices: LoadingState<SuggestedPriceGraphQL[]>;
+  providers: LoadingState<PayeeGraphQL[]>;
+  providerCategories: LoadingState<PayeeCategoryGraphQL[]>;
+  payees: LoadingState<PayeeGraphQL[]>;
+  payeesForLab: LoadingState<PayeeGraphQL[]>;
+  payeeCategoriesLabPrices: LoadingState<PayeeCategoryGraphQL[]>;
+  clientCategories: LoadingState<PayeeCategoryGraphQL[]>;
+  receptionTypes: LoadingState<WebAppRowGraphQL<ReceptionType>[]>;
+  tiposDeMuestra: LoadingState<WebAppRowGraphQL<TipoMuestra>[]>;
+  templates: LoadingState<WebAppRowGraphQL<Template>[]>;
+  shipments: LoadingState<ShipmentGraphQL[]>;
+  bookings: LoadingState<ShipmentGraphQL[]>;
+  motivosRechazo: LoadingState<WebAppRowGraphQL<MotivoRechazo>[]>;
+  bitacoraRechazoMasivo: LoadingState<WebAppRowGraphQL<BitacoraPOMassive>[]>;
+  items: LoadingState<ItemGraphQL[]>;
+  itemsByReception: LoadingState<ItemGraphQL[]>;
+  itemsByLab: LoadingState<ItemGraphQL[]>;
+  itemServicesByLab: LoadingState<ItemGraphQL[]>;
+  itemCategoriesForLab: LoadingState<ItemCategoryGraphQL[]>;
+  bundlesRecipForLab: LoadingState<BundleGraphQL[]>;
+  bundlesForLab: LoadingState<BundleGraphQL[]>;
+  currencies: LoadingState<CurrencyGraphQL[]>;
+  paymentTerms: LoadingState<PaymentTermGraphQL[]>;
+  employeesByLab: LoadingState<EmployeeGraphQL[]>;
+  employeesByCurrentAgency: LoadingState<EmployeeGraphQL[]>;
+  invoicesByLab: LoadingState<InvoiceGraphQL[]>;
+  invoiceForms: LoadingState<FormGraphQL[]>;
+  caseForms: LoadingState<FormGraphQL[]>;
+  invoiceFormSubmissions: LoadingState<FormSubmissionGraphQL[]>;
+  myCases: LoadingState<CaseGraphQL[]>;
+  myCaseFormSubmissions: LoadingState<FormSubmissionGraphQL[]>;
+  myAgencyLotStocks: LoadingState<LotStockGraphQL[]>;
+  shipmentsToMyAgency: LoadingState<ShipmentGraphQL[]>;
+};
+
+const createLoadingState = <T>(initialData: T): LoadingState<T> => ({
+  data: initialData,
+  loading: false,
+  reFetch: false,
+});
+
+const initialState: CatalogState = {
+  agencies: createLoadingState([]),
+  suggestedPrices: createLoadingState([]),
+  providers: createLoadingState([]),
+  providerCategories: createLoadingState([]),
+  receptionTypes: createLoadingState([]),
+  tiposDeMuestra: createLoadingState([]),
+  templates: createLoadingState([]),
+  shipments: createLoadingState([]),
+  bookings: createLoadingState([]),
+  motivosRechazo: createLoadingState([]),
+  bitacoraRechazoMasivo: createLoadingState([]),
+  items: createLoadingState([]),
+  itemsByReception: createLoadingState([]),
+  payees: createLoadingState([]),
+  payeesForLab: createLoadingState([]),
+  itemCategoriesForLab: createLoadingState([]),
+  payeeCategoriesLabPrices: createLoadingState([]),
+  clientCategories: createLoadingState([]),
+  itemsByLab: createLoadingState([]),
+  itemServicesByLab: createLoadingState([]),
+  bundlesRecipForLab: createLoadingState([]),
+  bundlesForLab: createLoadingState([]),
+  currencies: createLoadingState([]),
+  paymentTerms: createLoadingState([]),
+  employeesByLab: createLoadingState([]),
+  employeesByCurrentAgency: createLoadingState([]),
+  invoicesByLab: createLoadingState([]),
+  invoiceForms: createLoadingState([]),
+  caseForms: createLoadingState([]),
+  invoiceFormSubmissions: createLoadingState([]),
+  myCases: createLoadingState([]),
+  myCaseFormSubmissions: createLoadingState([]),
+  myAgencyLotStocks: createLoadingState([]),
+  shipmentsToMyAgency: createLoadingState([]),
+};
+
+const catalogsSlice = createSlice({
+  name: "catalogs",
+  initialState,
+  reducers: {
+    catalogsSetReFetch: (state, action: PayloadAction<CATALOGS_NAMES>) => {
+      state[action.payload].reFetch = true;
+    },
+    catalogsFetchStart: (state, action: PayloadAction<CATALOGS_NAMES>) => {
+      state[action.payload].loading = true;
+    },
+    catalogsFetchSuccess: (
+      state,
+      action: PayloadAction<{ name: CATALOGS_NAMES; data: any[] }>
+    ) => {
+      state[action.payload.name].data = action.payload.data;
+      state[action.payload.name].loading = false;
+      state[action.payload.name].reFetch = false;
+    },
+  },
+});
+
+export const { catalogsFetchStart, catalogsFetchSuccess, catalogsSetReFetch } =
+  catalogsSlice.actions;
+
+export default catalogsSlice.reducer;

package/src/slices/formValidation.slice.ts

@@ -0,0 +1,32 @@
+import { createSlice, type PayloadAction } from "@reduxjs/toolkit";
+
+export type FormValidations = {
+  formValidations: {
+    [key: string]: {
+      //formName
+      [key: string]: string; //fieldName
+    };
+  };
+};
+
+const initialState: FormValidations = {
+  formValidations: {},
+};
+
+const formValidationsSlice = createSlice({
+  name: "formValidations",
+  initialState,
+  reducers: {
+    setFieldError: (
+      state,
+      action: PayloadAction<{ formName: string; name: string; error: string }>
+    ) => {
+      state.formValidations[action.payload.formName][action.payload.name] =
+        action.payload.error;
+    },
+  },
+});
+
+export const { setFieldError } = formValidationsSlice.actions;
+
+export default formValidationsSlice.reducer;

package/src/slices/index.ts

@@ -0,0 +1,11 @@
+export * from "./agency.slice.js";
+export * from "./automaticNumbers.slice.js";
+export * from "./catalogs.slice.js";
+export * from "./formValidation.slice.js";
+export * from "./profile.slice.js";
+export * from "./reception.slice.js";
+export * from "./session.slice.js";
+export * from "./tables.slice.js";
+export * from "./templates.slice.js";
+export * from "./user.slice.js";
+export * from "./webapp-tables.slice.js";

package/src/slices/profile.slice.ts

@@ -0,0 +1,49 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+import type {
+  AgencyGraphQL,
+  EmployeeGraphQL,
+  OauthProfile,
+  ProfileResponse,
+} from "@zauru-sdk/types";
+
+export type PROFILE_NAMES =
+  | "userProfile"
+  | "oauthProfile"
+  | "employeeProfile"
+  | "agencyProfile";
+
+export interface ProfilesState {
+  userProfile: { loading: boolean; data: ProfileResponse };
+  oauthProfile: { loading: boolean; data: OauthProfile };
+  employeeProfile: { loading: boolean; data: EmployeeGraphQL };
+  agencyProfile: { loading: boolean; data: AgencyGraphQL };
+}
+
+const initialState: ProfilesState = {
+  userProfile: { data: {} as ProfileResponse, loading: false },
+  oauthProfile: { data: {} as OauthProfile, loading: false },
+  employeeProfile: { data: {} as EmployeeGraphQL, loading: false },
+  agencyProfile: { data: {} as AgencyGraphQL, loading: false },
+};
+
+const profileSlice = createSlice({
+  name: "profile",
+  initialState,
+  reducers: {
+    profileFetchStart: (state, action: PayloadAction<PROFILE_NAMES>) => {
+      state[action.payload].loading = true;
+    },
+    profileFetchSuccess: (
+      state,
+      action: PayloadAction<{ name: PROFILE_NAMES; data: any }>
+    ) => {
+      state[action.payload.name].data = action.payload.data;
+      state[action.payload.name].loading = false;
+    },
+  },
+});
+
+export const { profileFetchStart, profileFetchSuccess } = profileSlice.actions;
+
+export default profileSlice.reducer;

package/src/slices/reception.slice.ts

@@ -0,0 +1,118 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+import {
+  ItemAssociatedLots,
+  NewPurchaseOrderResponse,
+  PurchaseOrderGeneralInfo,
+  PurchaseOrderGraphQL,
+  RejectionWebAppTableObject,
+  WebAppRowGraphQL,
+  QueueFormReceptionWebAppTable,
+} from "@zauru-sdk/types";
+
+export type RECEPTION_NAMES =
+  | "basketLots"
+  | "rejectionInfo"
+  | "newPurchaseOrderInfo"
+  | "purchaseOrderGeneralInfo"
+  | "poReceptions"
+  | "queueNewReceptions";
+
+export interface ReceptionState {
+  basketLots: { loading: boolean; data: ItemAssociatedLots; reFetch: boolean };
+  rejectionInfo: {
+    loading: boolean;
+    data: RejectionWebAppTableObject;
+    reFetch: boolean;
+  };
+  newPurchaseOrderInfo: {
+    loading: boolean;
+    data: NewPurchaseOrderResponse;
+    reFetch: boolean;
+  };
+  purchaseOrderGeneralInfo: {
+    loading: boolean;
+    data: PurchaseOrderGeneralInfo;
+    reFetch: boolean;
+  };
+  poReceptions: {
+    loading: boolean;
+    data: PurchaseOrderGraphQL[];
+    reFetch: boolean;
+  };
+  queueNewReceptions: {
+    loading: boolean;
+    data: WebAppRowGraphQL<QueueFormReceptionWebAppTable>[];
+    reFetch: boolean;
+  };
+}
+
+const initialState: ReceptionState = {
+  basketLots: {
+    data: {} as ItemAssociatedLots,
+    loading: false,
+    reFetch: false,
+  },
+  rejectionInfo: {
+    data: {} as RejectionWebAppTableObject,
+    loading: false,
+    reFetch: false,
+  },
+  newPurchaseOrderInfo: {
+    data: {} as NewPurchaseOrderResponse,
+    loading: false,
+    reFetch: false,
+  },
+  purchaseOrderGeneralInfo: {
+    data: {} as PurchaseOrderGeneralInfo,
+    loading: false,
+    reFetch: false,
+  },
+  poReceptions: {
+    data: [],
+    loading: false,
+    reFetch: false,
+  },
+  queueNewReceptions: {
+    data: [],
+    loading: false,
+    reFetch: false,
+  },
+};
+
+const receptionSlice = createSlice({
+  name: "reception",
+  initialState,
+  reducers: {
+    receptionFetchStart: (state, action: PayloadAction<RECEPTION_NAMES>) => {
+      state[action.payload].loading = true;
+    },
+    receptionFetchSuccess: (
+      state,
+      action: PayloadAction<{ name: RECEPTION_NAMES; data: any }>
+    ) => {
+      state[action.payload.name].data = action.payload.data;
+      state[action.payload.name].loading = false;
+    },
+    receptionConcatToArray: (
+      state,
+      action: PayloadAction<{ name: RECEPTION_NAMES; data: any }>
+    ) => {
+      if (Array.isArray(state[action.payload.name].data)) {
+        state[action.payload.name].data = [
+          ...(state[action.payload.name].data as any),
+          action.payload.data,
+        ];
+      }
+      state[action.payload.name].loading = false;
+    },
+  },
+});
+
+export const {
+  receptionFetchStart,
+  receptionFetchSuccess,
+  receptionConcatToArray,
+} = receptionSlice.actions;
+
+export default receptionSlice.reducer;

package/src/slices/session.slice.ts

@@ -0,0 +1,25 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+
+export interface SessionState {
+  [key: string]: any;
+}
+
+const initialState: SessionState = {};
+
+const sessionSlice = createSlice({
+  name: "session",
+  initialState,
+  reducers: {
+    setSessionValue: (
+      state,
+      action: PayloadAction<{ name: string; data: any }>
+    ) => {
+      state[action.payload.name] = action.payload.data;
+    },
+  },
+});
+
+export const { setSessionValue } = sessionSlice.actions;
+
+export default sessionSlice.reducer;

package/src/slices/tables.slice.ts

@@ -0,0 +1,33 @@
+import type { PayloadAction } from "@reduxjs/toolkit";
+import { createSlice } from "@reduxjs/toolkit";
+
+export type TABLE_NAMES = "pageTable1" | "pageTable2" | "pageTable3";
+
+export interface TableState {
+  pageTable1: number;
+  pageTable2: number;
+  pageTable3: number;
+}
+
+const initialState: TableState = {
+  pageTable1: 1,
+  pageTable2: 1,
+  pageTable3: 1,
+};
+
+const tableSlice = createSlice({
+  name: "table",
+  initialState,
+  reducers: {
+    tableSetPage: (
+      state,
+      action: PayloadAction<{ name: TABLE_NAMES; data: number }>
+    ) => {
+      state[action.payload.name] = action.payload.data;
+    },
+  },
+});
+
+export const { tableSetPage } = tableSlice.actions;
+
+export default tableSlice.reducer;