npm-pkg-hook 1.12.9 → 1.13.1

package/src/hooks/useCart/useCart/index.ts

@@ -1,424 +0,0 @@
-import { useMutation } from '@apollo/client'
-import { useState, useCallback, useEffect } from 'react'
-
-import { RandomCode, updateCacheMod, numberFormat } from '../../../utils'
-import { useGetExtProductFoodsSubOptionalAll } from '../../useGetExtProductFoodsSubOptionalAll'
-import { useManageQueryParams } from '../../useManageQueryParams'
-import { useExtProductFoodsAll, useGetOneProductsFood } from '../../useProductsFood'
-import { CREATE_SHOPPING_CARD, GET_ALL_SHOPPING_CARD } from '../queries'
-import { useGetCart } from '../useGetCart'
-
-import {
-  filterDataOptional,
-  filterExtra,
-  validateExtraProducts,
-  validateRequirements
-} from './helpers'
-
-
-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) => {return subObj.check !== false}
-          )
-
-          if (filteredSubOptions.length === 0) {
-            return null
-          }
-
-          return {
-            ...obj,
-            ExtProductFoodsSubOptionalAll: filteredSubOptions
-          }
-        })
-        .filter((obj) => {return 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) => {return 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) => {return newItem && newItem.opSubExPid === subObj.opSubExPid})
-
-            if (newItem) {
-              return {
-                ...subObj,
-                check: true
-              }
-            }
-
-            return subObj
-          })
-
-          return {
-            ...obj,
-            ExtProductFoodsSubOptionalAll: updatedExtProductFoodsSubOptionalAll
-          }
-        }).filter((obj) => {return 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 => {return 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.
-   * @param root0
-   * @param root0.extra
-   * @param root0.index
-   */
-  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)
-    }
-  }
-
-  /**
-   *
-   * @param root0
-   * @param root0.extra
-   * @param root0.index
-   */
-  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) => {return 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) => {return item.code === codeCategory})
-    if (!item) return
-    const idx = item.ExtProductFoodsSubOptionalAll.findIndex(
-      (el) => {return 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) =>
-      {return el.code === codeCategory ? updatedItem : el}
-      )
-      setDataOptional((prevData) => {return [...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.ts

@@ -1,34 +0,0 @@
-import { useQuery } from '@apollo/client'
-
-import { GET_ALL_SHOPPING_CARD } from '../queries'
-
-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
-  }]
-}

package/src/hooks/useCatWithProduct/index.ts

@@ -1,54 +0,0 @@
-import { useQuery } from '@apollo/client'
-
-import { GET_ALL_CATEGORIES_WITH_PRODUCT } from './queries'
-import { GetCatProductsWithProductResponse, ICatWithProduct } from './types'
-
-export const useCatWithProduct = ({
-  max = 400,
-  min = 0,
-  search = null,
-  productName = null,
-  searchFilter = {},
-  callback = () => {}
-}: ICatWithProduct) => {
-  const {
-    gender,
-    desc,
-    speciality
-  } = searchFilter ?? {
-    gender: [],
-    desc: null,
-    speciality: []
-  }
-  const {
-    data,
-    loading,
-    error,
-    fetchMore
-  } = useQuery(GET_ALL_CATEGORIES_WITH_PRODUCT, {
-    onCompleted: (data) => {
-      callback(data as GetCatProductsWithProductResponse)
-    },
-    fetchPolicy: 'network-only',
-    variables:
-    {
-      search,
-      productName,
-      gender,
-      min,
-      max,
-      desc,
-      categories: speciality
-    }
-  })
-  const totalCount = data?.getCatProductsWithProduct?.totalCount
-  return [
-    data?.getCatProductsWithProduct?.catProductsWithProduct,
-    {
-      loading,
-      error,
-      fetchMore,
-      totalCount
-    }
-  ]
-}

package/src/hooks/useCatWithProduct/queries.ts

@@ -1,200 +0,0 @@
-import { gql } from '@apollo/client'
-
-export const CREATE_FOOD_PRODUCT = gql`
-  mutation  newRegisterFoodProduct($input: FoodProductInput){
-    newRegisterFoodProduct(input: $input){
-      success
-      message
-    }
-  }
-`
-export const GET_BANNER_PROMO_DASHBOARD = gql`
-query getPromoStoreAdmin($min: Int, $max: Int){
-getPromoStoreAdmin(min: $min, max: $max){
-    pSoId
-    comments
-    mainName
-    metaTags
-    urlImage
-    bPromoState
-    createAt
-    updateAt
-  }
-}
-`
-
-export const CREATE_STORE_CALENDAR = gql`
-mutation  setStoreSchedule($input: ITstoreSchedule!){
-  setStoreSchedule(input: $input){
-    message
-    success
-  }
-}
-`
-export const DELETE_ONE_CAT_PRODUCTS = gql`
-  mutation  deleteCatOfProducts($idPc: ID!, $pState: Int){
-  deleteCatOfProducts(idPc: $idPc, pState: $pState){
-    success
-    message
-  }
-}
-`
-export const DELETE_ONE_CAT_PRODUCTS_FINAL = gql`
-
-mutation deleteCatFinalOfProducts($idPc: ID, $withProduct: Boolean) {
-    deleteCatFinalOfProducts(idPc: $idPc, withProduct: $withProduct) {
-      success
-      message
-    }
-  }
-`
-export const DELETE_EXTRA_PRODUCTS = gql`
-  mutation  deleteExtraProduct($id: ID, $state: Int){
-    deleteExtraProduct(id: $id, state: $state){
-      success, 
-      message
-  }
-}
-`
-export const EDIT_EXTRA_PRODUCTS = gql`
-mutation editExtProductFoods($input: InputExtProductFood!) {
-  editExtProductFoods(input: $input) {
-    success
-    message
-  }
-}
-`
-export const DELETE_CAT_EXTRA_PRODUCTS = gql`
-  mutation  DeleteExtProductFoodsOptional($opExPid: ID, $state: Int){
-    DeleteExtProductFoodsOptional(opExPid: $opExPid, state: $state){
-      success, 
-      message
-  }
-}
-`
-export const DELETE_CAT_EXTRA_SUB_OPTIONAL_PRODUCTS = gql`
-  mutation  DeleteExtFoodSubsOptional($opSubExPid: ID, $state: Int){
-    DeleteExtFoodSubsOptional(opSubExPid: $opSubExPid, state: $state){
-      success, 
-      message
-  }
-}
-`
-export const UPDATE_CAT_IN_PRODUCT = gql`
-mutation  updatedCatWithProducts($input: LineItemsIdPro){
-  updatedCatWithProducts(input: $input){
-    success
-    message
-  }
-}
-`
-export const GET_ULTIMATE_CATEGORY_PRODUCTS = gql`
-query catProductsAll($search: String, $min: Int, $max: Int, $gender: [String], $desc: [String], $categories: [ID], ) {
-  catProductsAll(search: $search, min: $min, max: $max, gender: $gender, desc: $desc, categories: $categories,) {
-    carProId
-    idStore
-    pName
-    ProDescription
-    ProImage
-    pState
-    pDatCre
-    pDatMod
-  }
-}
-`
-export const GET_ALL_EXTRA_PRODUCT = gql`
-query ExtProductFoodsAll($search: String, $min: Int, $max: Int, $pId: ID) {
-  ExtProductFoodsAll(search: $search, min: $min, max: $max, pId: $pId) {
-    pId
-    exPid
-    exState
-    extraName
-    extraPrice
-    state
-    pDatCre
-    pDatMod
-  }
-}
-`
-export const GET_ALL_CATEGORIES_WITH_PRODUCT = gql`
-query getCatProductsWithProduct(
-  $search: String
-  $productName: String
-  $min: Int
-  $max: Int
-  $gender: [String]
-  $desc: [String]
-  $categories: [ID]
-) {
-  getCatProductsWithProduct(
-    search: $search
-    min: $min
-    productName: $productName
-    max: $max
-    gender: $gender
-    desc: $desc
-    categories: $categories
-  ) {
-    totalCount
-    catProductsWithProduct {
-      carProId
-      pState
-      pState
-      ProImage
-      idStore
-      pName
-      totalCount
-      ProDescription
-      ProImage
-      pState
-      createdAt
-      updatedAt
-      productFoodsAll {
-        pId
-        stock
-        manageStock
-        sizeId
-        colorId
-        carProId
-        cId
-        dId
-        ctId
-        idStore
-        caId
-        fId
-        pName
-        ProPrice
-        ProDescuento
-        ProUniDisponibles
-        ProDescription
-        ProProtegido
-        ProAssurance
-        ProImage
-        ProStar
-        ProWidth
-        ProHeight
-        ProLength
-        ProWeight
-        ProQuantity
-        ProOutstanding
-        ProDelivery
-        ProVoltaje
-        pState
-        sTateLogistic
-        createdAt
-        updatedAt
-        product_availables {
-          availableProductId
-          pId
-          idStore
-          dayAvailable
-          startDate
-          endDate
-          createdAt
-          updatedAt
-        }
-      }
-    }
-  }
-}
-`