npm-pkg-hook 1.9.8 → 1.10.0

package/package.json

@@ -47,5 +47,5 @@
     "rm": "rm -rf node_modules package-lock.json && npm i",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "1.9.8"
+  "version": "1.10.0"
 }

package/src/hooks/generateTemplate/index.js

@@ -54,7 +54,7 @@ export class GenerateReport {
    */
   GenExcelReportFileName (type) {
     const fileNames = {
-      1: 'report.xlsx'
+      1: `report_${new Date().toISOString().replace(/[:.]/g, '-')}.xlsx`
     }
 
     return fileNames[type] ? fileNames[type] : null

package/src/hooks/useEmployee/useCreateEmployee.js

@@ -5,6 +5,8 @@ import { CREATE_ONE_EMPLOYEE_STORE_AND_USER } from './queries'
 /**
  * Custom hook to handle the createOneEmployeeStoreAndUser mutation.
  *
+ * @param
+ * @param {Object}
  * @returns {{
  *   createEmployeeStoreAndUser: (input: IEmployeeStore) => Promise<void>,
  *   loading: boolean,
@@ -23,15 +25,29 @@ export const useCreateEmployeeStoreAndUser = ({
   onCompleted = () => {
     return {
     }
+  },
+  onError = () => {
+    return {
+    }
   }
 } = {}) => {
   const [createEmployeeStoreAndUserMutation, { loading, error, data }] = useMutation(CREATE_ONE_EMPLOYEE_STORE_AND_USER, {
+    onError: () => {
+      sendNotification({
+        description: 'Error creando empleado',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+    },
     onCompleted: (response) => {
       console.log(response)
       const { createOneEmployeeStoreAndUser } = response ?? {}
       const { message, success } = createOneEmployeeStoreAndUser ?? {}
+      if (success === false) {
+        onError(response)
+      }
       if (success) {
-        onCompleted()
+        onCompleted(response)
       }
       sendNotification({
         description: message,

package/src/hooks/useFormTools/index.js

@@ -60,8 +60,8 @@ export const useFormTools = ({
     }
     if (errSub) {
       sendNotification({
-        title: 'Completa los campos requeridos',
-        description: 'Error',
+        description: 'Completa los campos requeridos',
+        title: 'Error',
         backgroundColor: 'error'
       })
     }

package/src/hooks/useProductsFood/queriesStore.js

@@ -585,6 +585,7 @@ export const GET_ONE_PRODUCTS_FOOD = gql`
       fId
       pName
       ProPrice
+      ProBarCode
       ProDescuento
       ValueDelivery
       ProUniDisponibles

package/src/hooks/useUpdateMultipleProducts/index.js

@@ -1,17 +1,21 @@
 import { useMutation } from '@apollo/client'
 import { UPDATE_MULTIPLE_PRODUCTS } from './queries'
-import { CATEGORY_EMPTY, RandomCode } from '../../utils/index'
+import { CATEGORY_EMPTY } from '../../utils/index'
 import { useCategoriesProduct } from '../useCategoriesProduct'
 
 export const useUpdateMultipleProducts = ({
   sendNotification = () => { }
 }) => {
-  const [updateMultipleProducts, { data, loading, error }] = useMutation(UPDATE_MULTIPLE_PRODUCTS)
+  const [updateMultipleProducts, {
+    data,
+    loading,
+    error
+  }] = useMutation(UPDATE_MULTIPLE_PRODUCTS)
   const [dataCategoriesProducts] = useCategoriesProduct()
   const findEmptyCategory = dataCategoriesProducts?.find(category => category.pName === CATEGORY_EMPTY)
   const updateProducts = async (products) => {
+    console.log("🚀 ~ updateProducts ~ products:", products)
     const newProducts = products.map(product => {
-      const code = RandomCode(9)
       return {
         idStore: '',
         ProPrice: product.PRECIO_AL_PUBLICO,
@@ -19,12 +23,14 @@ export const useUpdateMultipleProducts = ({
         ValueDelivery: 0,
         ProDescription: product.DESCRIPCION,
         pName: product.NOMBRE,
-        pCode: code,
+        pCode: product.pCode,
         carProId: findEmptyCategory?.carProId ?? null,
         pState: 1,
         sTateLogistic: 1,
         ProStar: 0,
-        ProImage: 'https:http://localhost:8080',
+        ProImage: null,
+        vat: product['IMPUESTO (%)'],
+        ProBarCode: product.CODIGO_DE_BARRAS,
         ProHeight: null,
         ProWeight: '',
         ProOutstanding: 0,

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

@@ -0,0 +1 @@
+export * from './parseNumber'

package/src/hooks/useUploadProducts/helpers/parseNumber.js

@@ -0,0 +1,37 @@
+/**
+ * Parses a formatted number (string or number) and converts it into a float with two decimal places.
+ * @param {string|number} value - The number to parse (e.g., "1.500,00", "1500.00", 1500).
+ * @returns {string} Parsed number as a string in the format "1500.00".
+ * @throws Will throw an error if the input is not a valid formatted number.
+ */
+export const parseNumber = (value) => {
+  // Convert value to string if it's a number
+  const stringValue = typeof value === 'number' ? value.toString() : value
+
+  if (typeof stringValue !== 'string') {
+    throw new Error('Input must be a string or number')
+  }
+
+  // Remove thousands separators and adjust decimal separator
+  const sanitizedValue = stringValue
+    .replace(/\./g, '') // Removes thousands separators (.)
+    .replace(',', '.') // Changes comma to period for decimal
+
+  // Parse the sanitized value as a float
+  const parsedNumber = parseFloat(sanitizedValue)
+  if (isNaN(parsedNumber)) {
+    throw new Error('Invalid number format')
+  }
+
+  // Format the number with two decimal places
+  return parsedNumber.toFixed(2)
+}
+
+// Example usage:
+console.log(parseNumber('1.500,00')) // "1500.00"
+console.log(parseNumber('1500.00')) // "1500.00"
+console.log(parseNumber('1,500.50')) // "1500.50"
+console.log(parseNumber('500')) // "500.00"
+console.log(parseNumber('0,50')) // "0.50"
+console.log(parseNumber(1500)) // "1500.00"
+console.log(parseNumber(1500.5)) // "1500.50"

package/src/hooks/useUploadProducts/helpers/validateProductDataExcel.js

@@ -0,0 +1,65 @@
+export const validateProductDataExcel = (product, productIndex) => {
+  const expectedHeaders = [
+    {
+      name: 'NOMBRE',
+      required: true,
+      type: 'string'
+    },
+    {
+      name: 'PRECIO_AL_PUBLICO',
+      required: false,
+      type: 'number'
+    },
+    {
+      name: 'VALOR_DE_COMPRA',
+      required: false,
+      type: 'number'
+    },
+    {
+      name: 'CANTIDAD',
+      required: true,
+      type: 'number'
+    },
+    {
+      name: 'DESCRIPCION',
+      required: true,
+      type: 'string'
+    },
+    {
+      name: 'DESCUENTO',
+      required: false,
+      type: 'number'
+    },
+    {
+      name: 'CATEGORIA',
+      required: false,
+      type: 'string'
+    },
+    {
+      name: 'CODIGO_DE_BARRAS',
+      required: false,
+      type: 'string'
+    },
+    {
+      name: 'IMPUESTO (%)',
+      required: false,
+      type: 'number'
+    }
+  ]
+
+  const errors = []
+
+  // Validar encabezados requeridos
+  expectedHeaders.forEach(({ name, required, type }) => {
+    if (required && !(name in product)) {
+      errors.push(`Producto ${productIndex + 1}: Faltan la columna requerida: ${name}.`)
+    } else if (product[name] !== undefined) {
+      const isValidType = typeof product[name] === type || (type === 'number' && typeof product[name] === 'number' && !isNaN(product[name]))
+      if (!isValidType) {
+        errors.push(`Producto ${productIndex + 1}: El campo ${name} debe ser de tipo ${type}.`)
+      }
+    }
+  })
+
+  return errors // Retorna todos los errores encontrados
+}

package/src/hooks/useUploadProducts/index.js

@@ -1,15 +1,25 @@
 import { useState } from 'react'
 import * as XLSX from 'xlsx'
+import { RandomCode } from '../../utils'
+import { validateProductDataExcel } from './helpers/validateProductDataExcel'
 
-export const useUploadProducts = () => {
-  const [data, setData] = useState([])
+const STEPS = {
+  UPLOAD_FILE: 0,
+  UPLOAD_PRODUCTS: 1
+}
 
-  const [active, setActive] = useState(0)
-  const [overActive, setOverActive] = useState(0)
+export const useUploadProducts = ({
+  sendNotification = () => { return null }
+} = {}) => {
+  const [data, setData] = useState([])
+  const [isLoading, setIsLoading] = useState(false)
+  const [active, setActive] = useState(STEPS.UPLOAD_FILE)
+  const [overActive, setOverActive] = useState(STEPS.UPLOAD_FILE)
 
   const handleOverActive = (index) => {
     setOverActive(index)
   }
+
   const readExcelFile = (file) => {
     return new Promise((resolve, reject) => {
       const reader = new FileReader()
@@ -27,17 +37,383 @@ export const useUploadProducts = () => {
   }
 
   const onChangeFiles = async (files) => {
-    const filePromises = Array.from(files).map(file => readExcelFile(file))
-    const data = await Promise.all(filePromises)
-    setData(data.flat())
+    setIsLoading(true) // Activa el loader al inicio
+    try {
+      const filePromises = Array.from(files).map(file => readExcelFile(file))
+      const newData = await Promise.all(filePromises)
+
+      const newProducts = newData.flat().map((product, index) => {
+        const PRECIO_AL_PUBLICO = isNaN(product.PRECIO_AL_PUBLICO) ? 0.00 : product.PRECIO_AL_PUBLICO
+        const VALOR_DE_COMPRA = isNaN(product.VALOR_DE_COMPRA) ? 0.00 : product.VALOR_DE_COMPRA
+        const validationErrors = validateProductDataExcel(product, index)
+
+        const code = RandomCode(9)
+        return {
+          ...product,
+          CANTIDAD: isNaN(product.CANTIDAD) ? 1 : product.CANTIDAD,
+          ORIGINAL_CANTIDAD: isNaN(product.CANTIDAD) ? 1 : product.CANTIDAD,
+          free: false,
+          product: product?.DESCRIPCION,
+          pCode: code,
+          editing: false,
+          PRECIO_AL_PUBLICO,
+          VALOR_DE_COMPRA,
+          errors: validationErrors.length > 0 ? validationErrors : null
+        }
+      })
+
+      // Notificación de errores
+      newProducts.forEach(product => {
+        if (product.errors) {
+          // Enviar una notificación por cada error encontrado
+          product.errors.forEach(error => {
+            sendNotification({
+              description: error,
+              title: 'Error',
+              backgroundColor: 'error'
+            })
+          })
+        }
+      })
+
+      // Validar el número total de productos antes de actualizar el estado
+      setData(prevData => {
+        const currentLength = prevData.length
+        const totalProducts = currentLength + newProducts.length
+
+        if (totalProducts > 100) {
+          sendNotification({
+            description: 'Cannot add more products. You have reached the 100-product limit.',
+            title: 'Error',
+            backgroundColor: 'error'
+          })
+
+          // Calcular la cantidad de productos que se pueden agregar sin exceder el límite
+          const remainingSlots = 100 - currentLength
+          const productsToAdd = newProducts.slice(0, remainingSlots)
+          return [...prevData, ...productsToAdd]
+        } else {
+          // Agregar todos los nuevos productos si no se excede el límite
+          return [...prevData, ...newProducts]
+        }
+      })
+    } catch (error) {
+      sendNotification({
+        description: 'Un error ha ocurrido mientras se cargaba el archivo de productos.',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleSetActive = (index) => {
+    if (typeof index !== 'number' || index < 0 || index >= Object.keys(STEPS).length) {
+      sendNotification({
+        description: 'Invalid step index',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+      return
+    }
+    if (active === STEPS.UPLOAD_FILE && Boolean(!data.length)) return setActive(0)
+    if (active === STEPS.UPLOAD_FILE && Boolean(data.length)) return setActive(STEPS.UPLOAD_PRODUCTS)
   }
 
+  const updateProductQuantity = (index, quantityChange) => {
+    // Validar el índice
+    if (index < 0 || index >= data.length) {
+      console.warn('Invalid product index:', index)
+      return
+    }
+
+    const newData = [...data]
+    const newQuantity = newData[index].CANTIDAD + quantityChange
+
+    // Actualizar la cantidad solo si es mayor o igual a 0
+    if (newQuantity < 0) {
+      console.warn('Quantity cannot be negative, no update performed.')
+      return // No permitir cantidades negativas
+    }
+
+    // Actualizar la cantidad
+    newData[index].CANTIDAD = newQuantity
+    newData[index].ORIGINAL_CANTIDAD = newQuantity
+    // Eliminar el producto si la nueva cantidad es 0
+    if (newData[index].CANTIDAD === 0) {
+      newData.splice(index, 1)
+
+      // Verificar si no quedan más productos
+      if (newData.length === 0) {
+        setActive(STEPS.UPLOAD_FILE) // Restablecer el estado activo a 0 si no hay productos
+      }
+    }
+
+    setData(newData)
+  }
+  /**
+ * Toggle the 'free' status of a specific product in the data array.
+ * Performs validation to ensure the product index is valid.
+ *
+ * @param {number} productIndex - The index of the product to update.
+ */
+  const handleCheckFree = (productIndex) => {
+    setData((prevData) => {
+    // Validar que el índice es un número válido
+      if (typeof productIndex !== 'number' || productIndex < 0 || productIndex >= prevData.length) {
+        console.warn('Invalid product index:', productIndex)
+        return prevData // Retorna el estado anterior si el índice es inválido
+      }
+
+      // Validar que el producto existe y que tiene la propiedad 'free'
+      const product = prevData[productIndex]
+      if (!product || typeof product.free === 'undefined') {
+        console.warn('Product or "free" property not found for index:', productIndex)
+        return prevData // Retorna el estado anterior si no se encuentra el producto
+      }
+
+      // Evitar cambios innecesarios si el estado de 'free' no cambia
+      const updatedFreeStatus = !product.free
+      if (product.free === updatedFreeStatus) {
+        console.info('Product "free" status is already:', updatedFreeStatus)
+        return prevData // No actualiza si el estado es el mismo
+      }
+
+      // Crear una nueva copia de los datos actualizando solo el producto específico
+      return prevData.map((product, index) =>
+        index === productIndex
+          ? {
+              ...product,
+              free: updatedFreeStatus,
+              PRECIO_AL_PUBLICO: updatedFreeStatus ? 0 : product.oldPrice,
+              oldPrice: product.PRECIO_AL_PUBLICO
+            }
+          : product
+      )
+    })
+  }
+  const handleCleanAllProducts = () => {
+    setData([])
+    setActive(STEPS.UPLOAD_FILE)
+  }
+  /**
+ * Toggle the 'editing' status of a specific product in the data array.
+ * Validates the product index and only updates if necessary.
+ *
+ * @param {number} productIndex - The index of the product to update.
+ */
+  const handleToggleEditingStatus = (productIndex) => {
+    setData((prevData) => {
+    // Validar que el índice es un número válido
+      if (typeof productIndex !== 'number' || productIndex < 0 || productIndex >= prevData.length) {
+        sendNotification({
+          description: `Invalid product index: ${productIndex}`,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+        return prevData // Retorna el estado anterior si el índice es inválido
+      }
+
+      // Validar que el producto existe y tiene la propiedad 'editing'
+      const product = prevData[productIndex]
+      if (!product || typeof product.editing === 'undefined') {
+        sendNotification({
+          description: `Product or "editing" property not found for index: ${productIndex}`,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+        return prevData // Retorna el estado anterior si no se encuentra el producto
+      }
+
+      // Evitar cambios innecesarios si el estado de 'editing' no cambia
+      const updatedEditingStatus = !product.editing
+      if (product.editing === updatedEditingStatus) {
+        sendNotification({
+          description: `Product "editing" status is already: ${updatedEditingStatus}`,
+          title: 'Info',
+          backgroundColor: 'info'
+        })
+        return prevData // No actualiza si el estado es el mismo
+      }
+
+      // Crear una nueva copia de los datos actualizando solo el producto específico
+      return prevData.map((product, index) => {
+        console.log(index === productIndex)
+        return index === productIndex
+          ? {
+              ...product,
+              editing: updatedEditingStatus
+            }
+          : product
+      }
+      )
+    })
+  }
+
+  /**
+   * Confirm and update the quantity of a product in the data array.
+   * Only updates when the button is clicked.
+   *
+   * @param {number} productIndex - The index of the product to update.
+   */
+  const handleSuccessUpdateQuantity = (productIndex) => {
+    const product = data[productIndex]
+    setData((prevData) => {
+      // Validar que `CANTIDAD` sea un número entero
+      const product = prevData[productIndex]
+      if (!Number.isInteger(product?.CANTIDAD)) {
+        sendNotification({
+          description: 'La cantidad debe ser un valor entero.',
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+        return prevData // Retorna el estado anterior si `CANTIDAD` no es entero
+      }
+
+      // Crear una copia actualizada de prevData donde se actualiza `CANTIDAD` si es necesario
+      const updatedData = prevData.map((product, index) =>
+        index === productIndex
+          ? { ...product, editing: false, ORIGINAL_CANTIDAD: product.CANTIDAD } // Actualización o cambio de estado
+          : product
+      )
+
+      // Filtrar productos con CANTIDAD mayor a 0
+      const filteredData = updatedData.filter(product => product.CANTIDAD > 0)
+
+      // Cambiar el estado a `STEPS.UPLOAD_FILE` si no quedan productos
+      if (filteredData.length === 0) {
+        setActive(STEPS.UPLOAD_FILE)
+      }
+
+      return filteredData
+    })
+    if (product.CANTIDAD !== data[productIndex].ORIGINAL_CANTIDAD) {
+      sendNotification({
+        description: `Cantidad actualizada con éxito para el producto ${product.NOMBRE} #${productIndex}.`,
+        title: 'Éxito',
+        backgroundColor: 'success'
+      })
+    }
+  }
+
+  const handleChangeQuantity = (event, productIndex) => {
+    const { value } = event.target
+    setData((prevData) => {
+      if (typeof productIndex !== 'number' || productIndex < 0 || productIndex >= prevData.length) {
+        console.warn('Invalid product index:', productIndex)
+        return prevData // Retorna el estado anterior si el índice es inválido
+      }
+
+      // Obtener la cantidad temporal para el producto
+      const newQuantity = value
+      if (isNaN(newQuantity) || newQuantity < 0) {
+        console.warn('Quantity must be a valid non-negative number.')
+        return prevData // Retorna sin cambios si la cantidad no es válida
+      }
+
+      // Actualiza el array `data` con la nueva cantidad
+      return prevData.map((product, index) =>
+        index === productIndex
+          ? { ...product, CANTIDAD: newQuantity }
+          : product
+      )
+    })
+  }
+  /**
+ * Restore the 'CANTIDAD' value to 'ORIGINAL_CANTIDAD' for a specific product.
+ * Validates the product index and only updates if necessary.
+ *
+ * @param {number} productIndex - The index of the product to restore quantity for.
+ */
+  const handleCancelUpdateQuantity = (productIndex) => {
+    setData((prevData) => {
+    // Validar que el índice es un número válido
+      if (typeof productIndex !== 'number' || productIndex < 0 || productIndex >= prevData.length) {
+        console.warn('Invalid product index:', productIndex)
+        return prevData // Retorna el estado anterior si el índice es inválido
+      }
+
+      // Validar que el producto existe y tiene las propiedades 'CANTIDAD' y 'ORIGINAL_CANTIDAD'
+      const product = prevData[productIndex]
+      if (!product || typeof product.ORIGINAL_CANTIDAD === 'undefined') {
+        console.warn('Product or "ORIGINAL_CANTIDAD" property not found for index:', productIndex)
+        return prevData // Retorna el estado anterior si no se encuentra el producto o propiedad
+      }
+
+      // Crear una nueva copia de los datos actualizando solo el producto específico
+      return prevData.map((product, index) =>
+        index === productIndex
+          ? { ...product, CANTIDAD: product.ORIGINAL_CANTIDAD, editing: false }
+          : product
+      )
+    })
+  }
+  /**
+ * Filters products with a quantity of 0 or less from the data array.
+ * Sends a notification if any products are found with invalid quantities.
+ */
+  const filterInvalidQuantityProducts = () => {
+    setData((prevData) => {
+    // Filtrar productos con `CANTIDAD` mayor a 0
+      const validProducts = prevData.filter(product => product.CANTIDAD > 0)
+
+      // Notificar si hubo productos con cantidad no válida
+      if (validProducts.length < prevData.length) {
+        sendNotification({
+          description: 'Some products had a quantity of 0 or less and were removed.',
+          title: 'Invalid Products Removed',
+          backgroundColor: 'warning'
+        })
+      }
+
+      return validProducts
+    })
+  }
+
+  /**
+ * Compares uploaded products against response data to determine which were successfully uploaded.
+ * @param {Array} data - Original array of products with their details.
+ * @param {Array} response - Array of response objects from the `updateProducts` function.
+ * @returns {Object} Object containing arrays of successfully and unsuccessfully uploaded products.
+ */
+  const getUploadResults = (data, response) => {
+    const uploadedCodes = new Set(
+      response
+        .filter((product) => product.success)
+        .map((product) => product.data.pCode)
+    )
+
+    const successfullyUploaded = data.filter((product) =>
+      uploadedCodes.has(product.pCode)
+    )
+
+    const failedUploads = data.filter(
+      (product) => !uploadedCodes.has(product.pCode)
+    )
+
+    return {
+      successfullyUploaded,
+      failedUploads
+    }
+  }
   return {
     active,
+    STEPS,
+    isLoading,
     data,
     overActive,
     handleOverActive,
+    handleCheckFree,
+    getUploadResults,
     onChangeFiles,
-    setActive
+    handleChangeQuantity,
+    handleCancelUpdateQuantity,
+    handleToggleEditingStatus,
+    filterInvalidQuantityProducts,
+    handleSuccessUpdateQuantity,
+    updateProductQuantity,
+    handleCleanAllProducts,
+    setActive: handleSetActive
   }
 }