npm-pkg-hook 1.12.4 → 1.12.7

package/src/hooks/useBanner/index.js

@@ -1,19 +0,0 @@
-import { useQuery } from '@apollo/client'
-import { GET_ONE_BANNER_STORE } from '../useProductsFood/queriesStore'
-import { useStore } from '../useStore'
-
-export const useBanner = () => {
-  const [store, { loading: loaStore }] = useStore()
-
-  const {
-    data,
-    loading,
-    error
-  } = useQuery(GET_ONE_BANNER_STORE, {
-    context: { clientName: 'admin-server' },
-    variables: {
-      idStore: !loaStore && store?.idStore
-    }
-  })
-  return [data?.getOneBanners, { loading, error }]
-}

package/src/hooks/useCart/index.js

@@ -1,2 +0,0 @@
-export * from './useCart'
-export * from './useGetCart'

package/src/hooks/useCart/queries.js

@@ -1,174 +0,0 @@
-import { gql } from '@apollo/client'
-
-export const CREATE_SHOPPING_CARD = gql`
-  mutation registerShoppingCard(
-    $input: IShoppingCard
-    $idSubArray: IID_SUB_ITEMS
-  ) {
-    registerShoppingCard(input: $input, idSubArray: $idSubArray) {
-      ShoppingCard
-      id
-      pId
-      subProductsId
-      ShoppingCardRefCode
-      uuid
-      discountCardProduct
-      idUser
-      cName
-      idStore
-      cState
-      cDatCre
-      cDatMod
-      csDescription
-      cantProducts
-      comments
-    }
-  }
-`
-
-export const GET_ALL_SHOPPING_CARD = gql`
-  query getAllShoppingCard {
-    getAllShoppingCard {
-      ShoppingCard
-      cState
-      idStore
-      refCodePid
-      pId
-      comments
-      salesExtProductFoodOptional {
-        pId
-        opExPid
-        OptionalProName
-        state
-        code
-        required
-        numbersOptionalOnly
-        pDatCre
-        pDatMod
-        saleExtProductFoodsSubOptionalAll {
-          pId
-          opExPid
-          idStore
-          opSubExPid
-          OptionalSubProName
-          exCodeOptionExtra
-          exCode
-          state
-          pDatCre
-          pDatMod
-        }
-      }
-      ExtProductFoodsAll {
-        pId
-        exPid
-        exState
-        extraName
-        extraPrice
-        quantity
-        newExtraPrice
-        state
-        pDatCre
-        pDatMod
-      }
-      productFood {
-        pId
-        carProId
-        sizeId
-        colorId
-        idStore
-        cId
-        caId
-        dId
-        ctId
-        tpId
-        fId
-        pName
-        ProPrice
-        ProDescuento
-        ProUniDisponibles
-        ProDescription
-        ValueDelivery
-        ProProtegido
-        ProAssurance
-        ProImage
-        ProStar
-        ProWidth
-        ProHeight
-        ProLength
-        ProWeight
-        ProQuantity
-        ProOutstanding
-        ProDelivery
-        ProVoltaje
-        pState
-        sTateLogistic
-        pDatCre
-        pDatMod
-      }
-      cantProducts
-      getStore {
-        idStore
-        cId
-        scheduleOpenAll
-        getStoreSchedules {
-          schId
-          idStore
-          schDay
-          schHoSta
-          schHoEnd
-          schState
-        }
-        id
-        dId
-        ctId
-        scheduleOpenAll
-        catStore
-        neighborhoodStore
-        Viaprincipal
-        storeOwner
-        storeName
-        emailStore
-        storePhone
-        socialRaz
-        Image
-        banner
-        documentIdentifier
-        uPhoNum
-        ULocation
-        upLat
-        upLon
-        uState
-        siteWeb
-        description
-        NitStore
-        typeRegiments
-        typeContribute
-        secVia
-        addressStore
-        createdAt
-        pais {
-          cId
-          cName
-          cCalCod
-          cState
-          cDatCre
-          cDatMod
-        }
-        city {
-          ctId
-          dId
-          cName
-          cState
-        }
-        department {
-          dId
-          cId
-          dName
-          dState
-          dDatCre
-          dDatMod
-        }
-      }
-    }
-  }
-`

package/src/hooks/useCart/useCart/helpers/index.js

@@ -1,75 +0,0 @@
-import { filterKeyObject } from '../../../../utils'
-
-const filters = ['__typename']
-
-export const filterDataOptional = (dataOptional) => {
-  if (!Array.isArray(dataOptional)) {
-    throw new Error('Input data is not an array')
-  }
-
-  try {
-    const filteredDataOptional = dataOptional.map(item => {
-      const checkedSubOptions = item?.ExtProductFoodsSubOptionalAll?.filter(subItem => subItem.check === true)
-      const ExtProductFoodsSubOptionalAll = checkedSubOptions?.map(subItemsOptional => {
-        return {
-          ...filterKeyObject(subItemsOptional, filters)
-        }
-      })
-      return {
-        ...filterKeyObject(item, filters),
-        ExtProductFoodsSubOptionalAll
-      }
-    }).filter(item => item?.ExtProductFoodsSubOptionalAll.length > 0)
-    return filteredDataOptional
-  } catch (error) {
-    console.error('An error occurred while filtering data:', error.message)
-    return []
-  }
-}
-
-/**
- * Valida los requerimientos de elementos opcionales.
- * @param {Array} filteredDataOptional - El array de datos a validar.
- * @returns {boolean} Devuelve true si se cumplen los requerimientos, de lo contrario, false.
- */
-export function validateRequirements (filteredDataOptional) {
-  if (Array.isArray(filteredDataOptional)) {
-    for (const item of filteredDataOptional) {
-      if (item.required === 1) {
-        const checkedSubOptions = item?.ExtProductFoodsSubOptionalAll.filter(subItem => subItem.check === true)
-        if (checkedSubOptions.length !== item.numbersOptionalOnly) {
-          return true
-        }
-      }
-    }
-  }
-  return false
-}
-
-export function validateExtraProducts (dataExtra) {
-  const requiredItems = dataExtra.filter(item => item.exState === 1)
-
-  if (requiredItems.length > 0) {
-    const hasSelectedRequiredProduct = requiredItems.some(item => item.quantity > 0)
-    return hasSelectedRequiredProduct
-  }
-
-  return true
-}
-
-export const filterExtra = (dataExtra) => {
-  if (!Array.isArray(dataExtra)) {
-    throw new Error('Input data is not an array')
-  }
-  try {
-    const dataExtraFiltered = dataExtra.filter(extra => extra.quantity !== 0)
-      .map(extra => {
-        return {
-          ...filterKeyObject(extra, filters)
-        }
-      })
-    return dataExtraFiltered
-  } catch (error) {
-    return []
-  }
-}

package/src/hooks/useCart/useCart/index.js

@@ -1,412 +0,0 @@
-import { useState, useCallback, useEffect } from 'react'
-import { useMutation } from '@apollo/client'
-import { CREATE_SHOPPING_CARD, GET_ALL_SHOPPING_CARD } from '../queries'
-import { RandomCode, updateCacheMod, numberFormat } from '../../../utils'
-import { useExtProductFoodsAll, useGetOneProductsFood } from '../../useProductsFood'
-import { useGetExtProductFoodsSubOptionalAll } from '../../useGetExtProductFoodsSubOptionalAll'
-import { useGetCart } from '../useGetCart'
-import {
-  filterDataOptional,
-  filterExtra,
-  validateExtraProducts,
-  validateRequirements
-} from './helpers'
-import { useManageQueryParams } from '../../useManageQueryParams'
-
-export const useCart = ({
-  location = {
-    push: (props, state, { shallow }) => {
-      return { ...props, state, shallow }
-    },
-    query: {
-      plato: ''
-    }
-  },
-  openModalProduct = false,
-  handleMenu = (number) => { return number },
-  setOpenModalProduct = (boolean) => { return boolean },
-  setAlertBox = (args) => { return args }
-} = {}) => {
-  // sub products
-  const { handleCleanQuery } = useManageQueryParams({
-    location
-  })
-  const [loadingButton, setLoadingButton] = useState(false)
-  const [dataOptional, setDataOptional] = useState([])
-  const [dataExtra, setDataExtra] = useState([])
-  const [quantity, setQuantity] = useState(1)
-  const [comments, setComments] = useState('')
-  const queryParamProduct = location.query.plato
-  const [registerShoppingCard] = useMutation(CREATE_SHOPPING_CARD, {
-    onError: (error) => {
-      console.error('Error registering shopping card:', error)
-    }
-  })
-  // CUSTOM HOOKS
-  const [dataShoppingCard, { loading }] = useGetCart()
-  const [handleExtProductFoodsAll] = useExtProductFoodsAll()
-
-  const [ExtProductFoodsSubOptionalAll] = useGetExtProductFoodsSubOptionalAll()
-  const [dataOneProduct, setDataOneProduct] = useState({})
-  const [handleGetOneProduct,
-    {
-      loading: loadingProduct
-    }
-  ] = useGetOneProductsFood({ fetchOnlyProduct: true })
-
-  const getOneProduct = async food => {
-    const { pId } = food || {}
-
-    if (!pId) return {}
-    setOpenModalProduct(true)
-    const product = await handleGetOneProduct({ variables: { pId } })
-    const productFoodsOne = product?.data?.productFoodsOne || {}
-    setDataOneProduct(productFoodsOne)
-
-    const matchingItemInShoppingCart = dataShoppingCard?.find((item) => {
-      return item?.productFood && item?.productFood?.pId === pId
-    })
-    const matchingItemInShoppingCartOptional = matchingItemInShoppingCart?.salesExtProductFoodOptional || []
-    if (matchingItemInShoppingCart && queryParamProduct) {
-      setDataOneProduct({
-        ...productFoodsOne,
-        intoCart: true
-      })
-      const comments = matchingItemInShoppingCart?.comments
-      if (comments) {
-        setComments(comments)
-      }
-      const quantityProduct = matchingItemInShoppingCart?.cantProducts
-      if (quantityProduct) {
-        setQuantity(quantityProduct || 1)
-      }
-    }
-    const optionalAll = await ExtProductFoodsSubOptionalAll({
-      variables: { pId }
-    })
-    const optionalFetch = optionalAll?.data?.ExtProductFoodsOptionalAll
-    const shoppingCartOptionalAll = matchingItemInShoppingCart?.ExtProductFoodsAll || []
-    if (Array.isArray(optionalFetch)) {
-      // Filtra y procesa los objetos de optionalFetch
-      const filteredDataOptional = optionalFetch
-        .map((obj) => {
-          const filteredSubOptions = (obj.ExtProductFoodsSubOptionalAll || []).filter(
-            (subObj) => subObj.check !== false
-          )
-
-          if (filteredSubOptions.length === 0) {
-            return null
-          }
-
-          return {
-            ...obj,
-            ExtProductFoodsSubOptionalAll: filteredSubOptions
-          }
-        })
-        .filter((obj) => obj !== null)
-
-      if (matchingItemInShoppingCartOptional?.length === 0) {
-        setDataOptional(filteredDataOptional || [])
-      }
-
-      if (matchingItemInShoppingCartOptional?.length) {
-        // Actualiza los objetos de filteredDataOptional con información de matchingItemInShoppingCartOptional
-        const updateOption = filteredDataOptional?.map((obj) => {
-          const matchingArray = matchingItemInShoppingCartOptional?.find(
-            (o) => o && o.opExPid === obj.opExPid
-          )
-
-          if (!matchingArray) {
-            return obj
-          }
-
-          // Actualiza las propiedades específicas
-          const updatedExtProductFoodsSubOptionalAll = (obj.ExtProductFoodsSubOptionalAll || []).map((subObj) => {
-            const newItem = matchingArray.saleExtProductFoodsSubOptionalAll?.find((newItem) => newItem && newItem.opSubExPid === subObj.opSubExPid)
-
-            if (newItem) {
-              return {
-                ...subObj,
-                check: true
-              }
-            }
-
-            return subObj
-          })
-
-          return {
-            ...obj,
-            ExtProductFoodsSubOptionalAll: updatedExtProductFoodsSubOptionalAll
-          }
-        }).filter((obj) => obj)
-
-        setDataOptional(updateOption || [])
-      }
-    }
-    if (!pId || pId === '') return
-    const resultExtra = await handleExtProductFoodsAll(pId)
-    const originalArray = resultExtra?.data?.ExtProductFoodsAll
-
-    if (Array.isArray(originalArray) && originalArray?.length) {
-      const fetchedDataExtra = originalArray?.map(extra => {
-        const updatedExtra = shoppingCartOptionalAll?.find(updatedItem => updatedItem.exPid === extra.exPid)
-        if (updatedExtra) {
-          return {
-            ...extra,
-            quantity: updatedExtra?.quantity || 0,
-            newExtraPrice: updatedExtra?.newExtraPrice || 0
-          }
-        }
-        return {
-          ...extra,
-          quantity: 0
-        }
-      })
-
-      setDataExtra(fetchedDataExtra)
-    }
-  }
-
-  /**
-   * The function `handleIncrementExtra` updates the quantity and price of a specific extra product in
-   * an array based on the provided index and product ID.
-   */
-  function handleIncrementExtra ({ extra, index }) {
-    // Desestructura las propiedades necesarias de dataOneProduct
-    const { pId } = dataOneProduct || {}
-
-    // Desestructura exPid de extra o establece un valor predeterminado si no existe
-    const { exPid = null } = extra
-
-    if (exPid && pId) {
-      const newExtra = dataExtra.map((producto) => {
-        if (exPid === producto.exPid) {
-          // Desestructura la cantidad y el precio extra del producto o establece valores predeterminados
-          const { quantity = 0, extraPrice = 0 } = producto
-
-          // Calcula la nueva cantidad y el nuevo precio extra
-          const newQuantity = quantity + 1
-          const newExtraPrice = extraPrice * newQuantity
-
-          return {
-            ...producto,
-            quantity: newQuantity,
-            newExtraPrice
-          }
-        }
-        return producto
-      })
-
-      // Actualiza el estado de dataExtra con el nuevo array
-      setDataExtra(newExtra)
-    }
-  }
-
-  function handleDecrementExtra ({ extra, index }) {
-    // Desestructura las propiedades necesarias de dataOneProduct
-    const { pId } = dataOneProduct || {}
-
-    // Desestructura exPid de extra o establece un valor predeterminado si no existe
-    const { exPid = null } = extra
-
-    // Encuentra el índice del objeto extra en dataExtra
-    const extraIndex = dataExtra.findIndex((item) => item.exPid === exPid)
-
-    if (pId && exPid && extraIndex !== -1) {
-      const newExtra = dataExtra.map((producto, i) => {
-        if (exPid === producto.exPid) {
-          // Desestructura la cantidad y el precio extra del producto o establece valores predeterminados
-          const { quantity = 0, extraPrice = 0 } = producto
-
-          // Calcula la nueva cantidad, evitando que sea negativa
-          const newQuantity = Math.max(quantity - 1, 0)
-
-          // Calcula el nuevo precio extra
-          const newExtraPrice = newQuantity === 0 ? extraPrice : extraPrice * newQuantity
-
-          return {
-            ...producto,
-            quantity: newQuantity,
-            newExtraPrice
-          }
-        }
-        return producto
-      })
-
-      // Actualiza el estado de dataExtra con el nuevo array
-      setDataExtra(newExtra)
-    }
-  }
-
-  const handleIncrease = () => {
-    return setQuantity((prev) => { return prev + 1 })
-  }
-
-  const handleDecrease = () => {
-    return setQuantity((prev) => { return prev - 1 })
-  }
-
-  const handleCountProducts = useCallback((ProPrice, quantity) => {
-    if (!ProPrice || !quantity) {
-      return 0 // Manejo de valores nulos o no numéricos
-    }
-
-    const price = parseFloat(ProPrice)
-    const numericQuantity = parseInt(quantity, 10)
-
-    if (isNaN(price) || isNaN(numericQuantity)) {
-      return 0 // Manejo de valores no numéricos
-    }
-
-    if (numericQuantity <= 0 || price <= 0) {
-      return price // Manejo de cantidades o precios no positivos
-    }
-
-    const totalPrice = Math.abs(numericQuantity * price)
-    return numberFormat(totalPrice) // Si es necesario, aplicar formateo aquí
-  }, [dataOneProduct])
-
-  const handleAddOptional = ({ exOptional = null, codeCategory = null }) => {
-    if (!exOptional || !codeCategory) return
-    const item = dataOptional.find((item) => item.code === codeCategory)
-    if (!item) return
-    const idx = item.ExtProductFoodsSubOptionalAll.findIndex(
-      (el) => el.opSubExPid === exOptional
-    )
-    if (item && idx !== -1) {
-      const updatedItem = {
-        ...item,
-        ExtProductFoodsSubOptionalAll: [
-          ...item.ExtProductFoodsSubOptionalAll.slice(0, idx),
-          {
-            ...item.ExtProductFoodsSubOptionalAll[idx],
-            check: !item.ExtProductFoodsSubOptionalAll[idx].check
-          },
-          ...item.ExtProductFoodsSubOptionalAll.slice(idx + 1)
-        ]
-      }
-      const newData = dataOptional.map((el) =>
-        el.code === codeCategory ? updatedItem : el
-      )
-      setDataOptional((prevData) => [...newData])
-    }
-  }
-
-  const isValidDataExtra = (!dataExtra.length && !dataOneProduct?.pId) ? false : !validateExtraProducts(dataExtra)
-
-  const isValid = (!dataOptional.length && !dataOneProduct?.pId) ? false : validateRequirements(dataOptional)
-
-  const disabled = isValid || isValidDataExtra
-
-  /**
-   * Handles the addition of products to the cart.
-   *
-   * @param {Object} food - The selected food item.
-   */
-  const handleAddProducts = async (food) => {
-    if (!food) return
-    const idStore = food?.getStore?.idStore
-    if (!idStore) {
-      return
-    }
-    setLoadingButton(true)
-    const isExistItemInShoppingCart = dataShoppingCard?.find((item) => {
-      return item?.productFood && item?.productFood?.pId === food.pId
-    }) ?? null
-    if (!isExistItemInShoppingCart) handleMenu(1)
-    const filteredDataOptional = filterDataOptional(dataOptional)
-
-    const dataExtraFiltered = filterExtra(dataExtra)
-
-    const refCodePid = RandomCode(20)
-
-    const idShoppingCart = isExistItemInShoppingCart?.ShoppingCard
-    try {
-      const idStore = food?.getStore?.idStore
-      const response = await registerShoppingCard({
-        variables: {
-          input: {
-            ShoppingCard: idShoppingCart ?? null,
-            cState: 1,
-            pId: food.pId,
-            idStore,
-            refCodePid: idShoppingCart ? null : refCodePid,
-            comments,
-            cName: '',
-            cantProducts: quantity,
-            csDescription: '',
-            dataExtra: dataExtraFiltered || [],
-            dataOptional: filteredDataOptional || []
-          },
-          idSubArray: {
-            setID: []
-          }
-        },
-        update: (cache, { data: { getAllShoppingCard } }) => {
-          return updateCacheMod({
-            cache,
-            query: GET_ALL_SHOPPING_CARD,
-            nameFun: 'getAllShoppingCard',
-            dataNew: getAllShoppingCard
-          })
-        }
-      })
-
-      if (response?.data) {
-        if (!idShoppingCart) {
-          setAlertBox({ message: 'producto agregado al carrito' })
-        }
-        if (idShoppingCart) {
-          setAlertBox({ message: 'producto actualizado' })
-        }
-        // Perform actions after adding products to cart
-      }
-    } catch (error) {
-      setAlertBox({ message: 'Ocurrió un error al añadir el producto al carrito' })
-    }
-    setLoadingButton(false)
-  }
-
-  const handleShowModalProduct = () => {
-    if (openModalProduct) {
-      setDataExtra([])
-      setDataOneProduct({})
-      setQuantity(1)
-      setComments('')
-      setDataOptional([])
-    }
-    if (queryParamProduct && openModalProduct) {
-      handleCleanQuery('plato')
-    }
-    return setOpenModalProduct(!openModalProduct)
-  }
-
-  useEffect(() => {
-    if (queryParamProduct) {
-      const product = { pId: queryParamProduct }
-      getOneProduct(product)
-    }
-  }, [queryParamProduct])
-
-  return {
-    quantity,
-    disabled,
-    comments,
-    loading: loadingProduct || loading,
-    dataOneProduct,
-    loadingButton,
-    dataExtra,
-    dataOptional,
-    setQuantity,
-    handleShowModalProduct,
-    handleDecrease,
-    handleIncrease,
-    getOneProduct,
-    handleIncrementExtra,
-    handleDecrementExtra,
-    handleAddOptional,
-    setComments,
-    handleCountProducts,
-    handleAddProducts
-  }
-}

package/src/hooks/useCart/useGetCart/index.js

@@ -1,33 +0,0 @@
-import { GET_ALL_SHOPPING_CARD } from '../queries'
-import { useQuery } from '@apollo/client'
-
-export const useGetCart = ({
-  setAlertBox = ({
-    message
-  }) => { return { message } },
-  setCountItemProduct = (number) => { return number }
-} = {}) => {
-  const {
-    data,
-    loading,
-    error,
-    called
-  } = useQuery(GET_ALL_SHOPPING_CARD, {
-    onCompleted: data => {
-      if (Array.isArray(data?.getAllShoppingCard) && Number(data?.getAllShoppingCard?.length)) {
-        setCountItemProduct(data?.getAllShoppingCard?.length)
-      }
-    },
-    fetchPolicy: 'cache-and-network',
-    onError: () => {
-      setAlertBox({ message: 'No pudimos cargar el carrito...' })
-    }
-  })
-  const cart = data?.getAllShoppingCard || []
-  return [cart, {
-    data,
-    called,
-    loading,
-    error
-  }]
-}