npm-pkg-hook 1.13.0 → 1.13.1

package/src/hooks/useTotalProductsSolded/index.ts

@@ -1,20 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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
-  }
-}