npm-pkg-hook 1.12.7 → 1.12.9

package/src/hooks/useTotalProductsSolded/index.ts

@@ -0,0 +1,20 @@
+import { useQuery, gql } from '@apollo/client'
+
+const GET_TOTAL_PRODUCTS_SOLD = gql`
+  query {
+    getTotalProductsSold
+  }
+`
+
+/**
+ * Custom hook to fetch the total number of products sold.
+ * @returns {{ totalSold: number, loading: boolean, error: any }}
+ */
+export const useTotalProductsSolded = () => {
+  const { data, loading, error } = useQuery(GET_TOTAL_PRODUCTS_SOLD)
+
+  return [data?.getTotalProductsSold, {
+    loading,
+    error
+  }]
+}

package/src/hooks/useUpdateCart/index.ts

@@ -0,0 +1,131 @@
+import debounce from 'lodash'
+import { useState, useEffect } from 'react'
+
+import { Cookies } from '../../cookies'
+import { getCurrentDomain } from '../../utils'
+import { trigger } from '../useEvent'
+
+// EXAMPLE
+// https://codesandbox.io/s/nextjs-cart-system-tfg1e?file=/pages/_app.js
+
+// Method to execute the event to add all items of the app.cart cookie
+const updateCart = debounce.debounce((items = []) => {
+  trigger({ eventType: 'app.cart', data: { loading: true, items } })
+}, 3000)
+
+const EMPTY_CART = {
+  items: [],
+  total: 0
+}
+
+export const useUpdateCart = () => {
+  const domain = getCurrentDomain()
+  const keyToSaveData = 'app.cart'
+  const saveDataState = JSON.parse(Cookies.get(keyToSaveData) || '[]')
+  const [cart, setCart] = useState(EMPTY_CART)
+
+  useEffect(() => {
+    // restore cart from cookie, this could also be tracked in a db
+    const cart = Cookies.get(keyToSaveData)
+
+    // if items in cart, set items and total to state
+    if (typeof cart === 'string' && cart !== 'undefined') {
+      const cartData = JSON.parse(cart)
+      const total = cartData.reduce(
+        (total, item) => { return total + item.price * item.quantity },
+        0
+      )
+
+      setCart({ items: cartData, total })
+    }
+  }, [])
+
+  useEffect(() => {
+    Cookies.set(keyToSaveData, JSON.stringify(cart.items), { domain, path: '/' })
+  }, [cart, domain])
+
+  const handleAdd = (item) => {
+    // check for item already in cart
+    // if not in cart, add item else if item is found increment quantity
+    const itemExists = cart.items.find((i) => { return i.pId === item.pId })
+
+    if (!itemExists) {
+      setCart((prevCart) => {
+        return {
+          items: [...prevCart.items, { ...item, quantity: 1 }],
+          total: prevCart.total + item.price
+        }
+      })
+
+      return
+    }
+
+    setCart((prevCart) => {
+      return {
+        items: prevCart.items.map((i) => {
+          if (i.pId === item.pId) {
+            return { ...i, quantity: i.quantity + 1 }
+          }
+
+          return i
+        }),
+        total: prevCart.total + item.price
+      }
+    })
+    updateCart(cart)
+  }
+
+  const deleteProductCart = (item) => {
+    setCart((prevCart) => {
+      const items = prevCart.items
+      const index = items.findIndex((i) => { return i.pId === item.pId })
+
+      items.splice(index, 1)
+
+      const total = items.reduce((t, i) => { return t + i.quantity * i.price }, 0)
+
+      return { items, total }
+    })
+  }
+
+  const decreaseItemFromCart = (item) => {
+    // check for item already in cart
+    // if quantity is more then  in cart, subtract item else remove item
+    const itemInCart = cart.items.find((i) => { return i.pId === item.pId })
+
+    if (!itemInCart) {
+      return
+    }
+
+    if (itemInCart.quantity === 1) {
+      deleteProductCart(item)
+
+      return
+    }
+
+    setCart((prevCart) => {
+      return {
+        items: prevCart.items.map((i) => {
+          if (i.pId === item.pId) {
+            return { ...i, quantity: item.quantity - 1 }
+          }
+
+          return i
+        }),
+        total: prevCart.total - item.price
+      }
+    })
+  }
+
+  const clearCart = () => {
+    setCart(EMPTY_CART)
+  }
+
+  return {
+    saveDataState,
+    clearCart,
+    deleteProductCart,
+    decreaseItemFromCart,
+    handleAdd
+  }
+}

package/src/hooks/useUpdateCartCookie/index.ts

@@ -0,0 +1,60 @@
+import { useEffect, useReducer } from 'react'
+
+import { Cookies } from '../../cookies'
+import { getCurrentDomain } from '../../utils'
+
+type Product = {
+  pId: string;
+  ProQuantity: number;
+  [key: string]: any;
+};
+
+type State = {
+  PRODUCT: Product[];
+  counter: number;
+};
+
+type Action =
+  | { type: 'REMOVE_PRODUCT_TO_CART'; payload: Product }
+  | { type: 'ADD_PRODUCT_TO_CART'; payload: Product }
+  | { type: 'UPDATE_PRODUCT_IN_CART'; payload: Product }
+  | { type: string; payload?: any };
+
+export const useUpdateCartCookie = () => {
+  const keyToSaveData = process.env.NEXT_LOCAL_SALES_STORE
+  const domain = getCurrentDomain()
+
+  const PRODUCT = (state: State, action: Action): State => {
+    switch (action.type) {
+      case 'REMOVE_PRODUCT_TO_CART':
+        return {
+          ...state,
+          PRODUCT: state?.PRODUCT?.filter((t: Product) => {
+            return t.pId !== action?.payload.pId
+          }),
+          counter: state.counter - action.payload.ProQuantity
+        }
+      case 'ADD_PRODUCT_TO_CART':
+        // Add code for 'ADD_PRODUCT_TO_CART' case
+        return state
+      case 'UPDATE_PRODUCT_IN_CART':
+        // Add code for 'UPDATE_PRODUCT_IN_CART' case
+        return state
+      default:
+        return state
+    }
+  }
+  const [data, dispatch] = useReducer(PRODUCT, { PRODUCT: [], counter: 0 })
+
+  const handleRemoveProductToCookieCart = (product: Product) => {
+    dispatch({ type: 'REMOVE_PRODUCT_TO_CART', payload: product })
+  }
+  useEffect(() => {
+    // @ts-ignore
+    Cookies.set(keyToSaveData, JSON.stringify(data), { domain, path: '/' })
+  }, [data, domain])
+
+  return {
+    handleRemoveProductToCookieCart
+  }
+}

package/src/hooks/useUpdateDashboardComponent/index.ts

@@ -0,0 +1,91 @@
+import { gql, useMutation } from '@apollo/client'
+
+/**
+ * GraphQL mutation for updating a dashboard component.
+ */
+const UPDATE_DASHBOARD_COMPONENT = gql`
+  mutation UpdateDashboardComponent($input: [DashboardComponentUpdateInput]) {
+    updateDashboardComponent(input: $input) {
+      success
+      message
+      data {
+        id
+        idStore
+        idUser
+        coordinates
+        createAt
+        updateAt
+        title
+      }
+      errors {
+      path
+      message
+      type
+      }
+    }
+  }
+`
+
+/**
+ * Types for the mutation response and input.
+ */
+interface DashboardComponent {
+  id: string;
+  idStore: string;
+  idUser: string;
+  coordinates: any;
+  createAt: string;
+  updateAt: string;
+  title: string;
+}
+
+interface ErrorResponse {
+  message: string;
+  field?: string;
+}
+
+interface UpdateDashboardComponentResponse {
+  updateDashboardComponent: {
+    success: boolean;
+    message?: string;
+    data?: DashboardComponent;
+    errors?: ErrorResponse[];
+  };
+}
+
+interface UpdateDashboardComponentInput {
+  id: string;
+  coordinates?: any;
+  title?: string;
+}
+
+/**
+ * Custom hook to update a dashboard component.
+ */
+export const useUpdateDashboardComponent = () => {
+  const [mutate, { loading, error, data }] = useMutation<
+    UpdateDashboardComponentResponse,
+    { input: UpdateDashboardComponentInput[] }
+  >(UPDATE_DASHBOARD_COMPONENT)
+
+  /**
+   * Calls the mutation with the provided input.
+   * @param input DashboardComponentUpdateInput
+   */
+  const updateComponent = async (input: UpdateDashboardComponentInput[]) => {
+    try {
+      const response = await mutate({ variables: { input } })
+      return response.data?.updateDashboardComponent
+    } catch (err) {
+      console.error('UpdateDashboardComponent Error:', err)
+      throw err
+    }
+  }
+
+  return {
+    updateComponent,
+    loading,
+    error,
+    data: data?.updateDashboardComponent
+  }
+}

package/src/hooks/useUpdateExistingOrders/index.ts

@@ -0,0 +1,85 @@
+export const isValidCodeRef = (codeRef) => {
+  return typeof codeRef === 'string' && codeRef.trim() !== ''
+}
+
+export const updateExistingOrders = (
+  existingOrders,
+  pCodeRef,
+  pSState,
+  objectToAdd
+) => {
+  if (typeof existingOrders !== 'object' || existingOrders === null) {
+    // existingOrders no es un objeto válido
+    return existingOrders
+  }
+  if (typeof pCodeRef !== 'string') {
+    // Los tipos de datos de pCodeRef
+    return existingOrders
+  }
+  if (!isValidCodeRef(pCodeRef)) {
+    // Valores de entrada no válidos, devuelve existingOrders sin cambios
+    return existingOrders
+  }
+
+  const updatedExistingOrders = { ...existingOrders } // Copiar el objeto existente
+
+  const statusKeys = {
+    1: 'ACCEPT',
+    2: 'PROCESSING',
+    3: 'READY',
+    4: 'CONCLUDES',
+    5: 'REJECTED'
+  }
+  const targetArray = statusKeys[pSState]
+
+  if (!targetArray || !(targetArray in existingOrders)) {
+    // El valor de pSState no está mapeado a ninguna propiedad existente en existingOrders
+    return existingOrders
+  }
+  Object.keys(updatedExistingOrders).forEach((key) => {
+    if (Array.isArray(updatedExistingOrders[key])) {
+      const oneSale = updatedExistingOrders[key].find((order) => {
+        return order.pCodeRef === pCodeRef
+      })
+
+      updatedExistingOrders[key] = updatedExistingOrders[key].filter(
+        (order) => {
+          return order.pCodeRef !== pCodeRef
+        }
+      )
+
+      if (oneSale !== undefined && oneSale !== null) {
+        const updatedOneSale = { ...oneSale, pSState }
+
+        if (!Array.isArray(updatedExistingOrders[targetArray])) {
+          updatedExistingOrders[targetArray] = []
+        }
+
+        updatedExistingOrders[targetArray] = [
+          updatedOneSale,
+          ...updatedExistingOrders[targetArray]
+        ]
+      }
+    }
+  })
+
+  if (objectToAdd && objectToAdd.pCodeRef === pCodeRef) {
+    if (!Array.isArray(updatedExistingOrders[targetArray])) {
+      updatedExistingOrders[targetArray] = []
+    }
+
+    updatedExistingOrders[targetArray] = [
+      objectToAdd,
+      ...updatedExistingOrders[targetArray]
+    ]
+  }
+
+  // Asegurar que todas las propiedades estén presentes
+  Object.keys(statusKeys).forEach((statusKey) => {
+    if (!(statusKeys[statusKey] in updatedExistingOrders)) {
+      updatedExistingOrders[statusKeys[statusKey]] = []
+    }
+  })
+
+  return updatedExistingOrders
+}

package/src/hooks/useUpdateExtProductFoodsSubOptional/index.ts

@@ -0,0 +1,61 @@
+import { useMutation } from '@apollo/client'
+
+import { updateCacheMod } from '../../utils'
+import { GET_EXTRAS_PRODUCT_FOOD_OPTIONAL, GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL } from '../useProductsFood/queriesStore'
+
+export const useUpdateExtProductFoodsSubOptional = ({
+  sendNotification = (args) => { return args }
+} = {}) => {
+  const [updateExtProductSubOptional] = useMutation(GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL, {
+    onCompleted: (data) => {
+      console.log('🚀 ~ useUpdateExtProductFoodsSubOptional ~ data:', data)
+      const { updateExtProductSubOptional } = data ?? {}
+      const { success, message, errors } = updateExtProductSubOptional ?? {}
+      sendNotification({
+        description: message,
+        title: success ? 'Sub item creado' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+      for (const err of errors || []) {
+        const { message: msg } = err || {}
+        sendNotification({
+          description: msg,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+      }
+      return data
+    }
+  })
+
+  const handleMutateExtProductFoodsSubOptional = ({
+    pId,
+    title,
+    listId,
+    id,
+    state = 1
+  }) => {
+    updateExtProductSubOptional({
+      variables: {
+        input: {
+          pId,
+          OptionalSubProName: title,
+          exCodeOptionExtra: listId,
+          exCode: id,
+          state
+        }
+      },
+      update: (cache, { data: { ExtProductFoodsOptionalAll } }) => {
+        return updateCacheMod({
+          cache,
+          query: GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
+          nameFun: 'ExtProductFoodsOptionalAll',
+          dataNew: ExtProductFoodsOptionalAll
+        })
+      }
+    })
+  }
+  return {
+    handleMutateExtProductFoodsSubOptional
+  }
+}

package/src/hooks/useUpdateModuleOrder/index.ts

@@ -0,0 +1,37 @@
+import { gql, useMutation } from '@apollo/client'
+import { useCallback } from 'react'
+
+const UPDATE_MODULE_ORDER = gql`
+  mutation UpdateModuleOrder($input: [UpdateModuleOrderInput]!) {
+    updateModuleOrder(input: $input) {
+      success
+      message
+      modules {
+        mId
+        mPriority
+      }
+     errors {
+      path
+      message
+    }
+    }
+  }
+`
+
+export const useUpdateModuleOrder = () => {
+  const [updateModuleOrderMutation] = useMutation(UPDATE_MODULE_ORDER)
+
+  const updateModulesOrder = useCallback(async (newOrder) => {
+    // Enviar la actualización a la API (GraphQL)
+    try {
+      await updateModuleOrderMutation({
+        variables: { input: newOrder.map(({ mId, mPriority }) => {return { mId, mPriority }}) }
+      })
+    } catch (error) {
+      console.error('Error updating module order:', error)
+      throw new Error('Failed to update module order')
+    }
+  }, [updateModuleOrderMutation])
+
+  return [updateModulesOrder]
+}

package/src/hooks/useUpdateMultipleExtProduct/index.ts

@@ -0,0 +1,34 @@
+import { useMutation } from '@apollo/client'
+
+import { UPDATE_MULTI_EXTRAS_PRODUCT_FOOD } from './queries'
+
+/**
+ * Custom hook para manejar la actualización de múltiples extras de productos alimenticios.
+ * @param {Function} cleanLines - Función para limpiar líneas después de completar la mutación.
+ * @param {Function} handleCleanLines - Función.
+ * @returns {Array} Retorna un array con la función de mutación y el estado de carga.
+ */
+export const useUpdateMultipleExtProduct = ({
+  cleanLines = () => { },
+  handleCleanLines = () => { },
+  sendNotification = () => { }
+} = {
+  cleanLines: () => { },
+  handleCleanLines: () => { },
+  sendNotification: () => { }
+}) => {
+  const [updateMultipleExtProduct, { loading }] = useMutation(UPDATE_MULTI_EXTRAS_PRODUCT_FOOD, {
+    onCompleted: (data) => {
+      const { updateMultipleExtProduct: result } = data
+      const { success, message } = result ?? {}
+      sendNotification({
+        title: message,
+        description: success ? 'Operación exitosa' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+      cleanLines()
+    }
+  })
+
+  return [updateMultipleExtProduct, { loading }]
+}

package/src/hooks/useUpdateMultipleExtProduct/queries.ts

@@ -0,0 +1,33 @@
+import { gql } from '@apollo/client'
+
+// CREATE EXTRAS PRODUCT
+export const UPDATE_MULTI_EXTRAS_PRODUCT_FOOD = gql`
+mutation updateMultipleExtProduct($inputLineItems: ILineItemsExtraFinal) {
+  updateMultipleExtProduct(inputLineItems: $inputLineItems) {
+    success
+    message
+    data {
+      pId
+      exPid
+      exState
+      extraName
+      extraPrice
+      state
+      createdAt
+      updatedAt
+    }
+    errors {
+      path
+      message
+      type
+      context {
+        limit
+        value
+        label
+        key
+        __typename
+      }
+    }
+  }
+}
+`

package/src/hooks/useUpdateMultipleProducts/index.ts

@@ -0,0 +1,117 @@
+import { useMutation } from '@apollo/client'
+
+import { CATEGORY_EMPTY } from '../../utils/index'
+import { useCategoriesProduct } from '../useCategoriesProduct'
+
+import { UPDATE_MULTIPLE_PRODUCTS } from './queries'
+
+interface UpdateMultipleProductsProps {
+  sendNotification?: (notification: Notification) => void;
+}
+
+interface Product {
+  PRECIO_AL_PUBLICO: number;
+  DESCRIPCION: string;
+  NOMBRE: string;
+  pCode: string;
+  CANTIDAD?: number;
+  'IMPUESTO (%)': number;
+  CODIGO_DE_BARRAS: string | null;
+}
+
+interface Notification {
+  backgroundColor: string;
+  description: string;
+  title: string;
+}
+
+export const useUpdateMultipleProducts = ({
+  sendNotification = () => {}
+}: UpdateMultipleProductsProps): {
+    updateProducts: (products: Product[]) => Promise<any[]>;
+    data: any; 
+    loading: boolean; 
+    error: any; 
+} => {
+  
+  const [updateMultipleProducts, {
+    data,
+    loading,
+    error
+  }] = useMutation(UPDATE_MULTIPLE_PRODUCTS)
+
+  const [dataCategoriesProducts] = useCategoriesProduct()
+  
+  const findEmptyCategory = dataCategoriesProducts?.find(({ pName }: { pName: string }) => {return pName === CATEGORY_EMPTY})
+  
+  const updateProducts = async (products: Product[]): Promise<any[]> => {
+    
+    const newProducts = products.map(product => {
+      const {
+        PRECIO_AL_PUBLICO: ProPrice,
+        DESCRIPCION: ProDescription,
+        NOMBRE: pName,
+        pCode,
+        CANTIDAD: stock = 0,
+        'IMPUESTO (%)': vat,
+        CODIGO_DE_BARRAS: ProBarCode
+      } = product
+
+      return {
+        idStore: '',
+        ProPrice,
+        ProDescuento: 0,
+        ValueDelivery: 0,
+        ProDescription,
+        pName,
+        pCode,
+        carProId: findEmptyCategory?.carProId ?? null,
+        pState: 1,
+        sTateLogistic: 1,
+        ProStar: 0,
+        stock,
+        ProImage: '/images/placeholder-image.webp',
+        vat,
+        ProBarCode: String(ProBarCode) || '',
+        ProHeight: null,
+        ProWeight: '',
+        ProOutstanding: 0,
+        ProDelivery: 0
+      }
+    })
+
+    try {
+      const response = await updateMultipleProducts({ variables: { input: newProducts } })
+      
+      for (const { errors } of response.data.updateMultipleProducts) {
+        
+        if (errors) {
+          sendNotification({
+            backgroundColor:'error',
+            description : errors[0].message ,
+            title : 'Error'
+          })
+        }
+      }
+      
+      return response.data.updateMultipleProducts
+
+    } catch (e) {
+      sendNotification({
+        backgroundColor:'error',
+        description :'Ocurrió un error al actualizar los productos',
+        title :'Error'
+      })
+      
+      return []
+    }
+    
+  }
+
+  return {
+    updateProducts, 
+    data, 
+    loading, 
+    error
+  }
+}