npm-pkg-hook 1.9.7 → 1.9.9

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.7"
+  "version": "1.9.9"
 }

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/index.js

@@ -22,6 +22,7 @@ export * from './useUploadProducts'
 export * from './useAmountInput'
 export * from './useColorByLetters'
 export * from './newMessageSubscription'
+export * from './usePWAInstall'
 export * from './useGetCookies'
 export * from './generateTemplate'
 export * from './isTokenExpired'

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/usePWAInstall/index.js

@@ -0,0 +1,38 @@
+import { useState, useEffect } from 'react';
+
+export const usePWAInstall = () => {
+  const [deferredPrompt, setDeferredPrompt] = useState(null);
+  const [isInstallable, setIsInstallable] = useState(false);
+
+  useEffect(() => {
+    const handleBeforeInstallPrompt = (e) => {
+      e.preventDefault(); // Evita que el navegador muestre el diálogo automáticamente
+      setDeferredPrompt(e); // Almacena el evento para que puedas llamarlo más tarde
+      setIsInstallable(true); // Marca que la PWA es instalable
+    };
+
+    window.addEventListener('beforeinstallprompt', handleBeforeInstallPrompt);
+
+    return () => {
+      window.removeEventListener('beforeinstallprompt', handleBeforeInstallPrompt);
+    };
+  }, []);
+
+  const installPWA = () => {
+    if (deferredPrompt) {
+      deferredPrompt.prompt();
+
+      deferredPrompt.userChoice.then((choiceResult) => {
+        if (choiceResult.outcome === 'accepted') {
+          console.log('User accepted the install prompt');
+        } else {
+          console.log('User dismissed the install prompt');
+        }
+        setDeferredPrompt(null); // Limpia el evento después de usarlo
+        setIsInstallable(false); // Oculta el botón de instalación
+      });
+    }
+  };
+
+  return { isInstallable, installPWA };
+};

package/src/hooks/useUpdateMultipleProducts/index.js

@@ -1,17 +1,20 @@
 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) => {
     const newProducts = products.map(product => {
-      const code = RandomCode(9)
       return {
         idStore: '',
         ProPrice: product.PRECIO_AL_PUBLICO,
@@ -19,12 +22,12 @@ 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,
         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/index.js

@@ -1,15 +1,24 @@
 import { useState } from 'react'
 import * as XLSX from 'xlsx'
+import { RandomCode } from '../../utils'
 
-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 +36,351 @@ 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) => {
+        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 code = RandomCode(9)
+        return {
+          ...product,
+          CANTIDAD: isNaN(product.CANTIDAD) ? 1 : product.CANTIDAD,
+          ORIGINAL_CANTIDAD: isNaN(product.CANTIDAD) ? 1 : product.CANTIDAD,
+          free: false,
+          pCode: code,
+          editing: false,
+          PRECIO_AL_PUBLICO,
+          VALOR_DE_COMPRA
+        }
+      })
+
+      // 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 errro a 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) {
+        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 la propiedad 'editing'
+      const product = prevData[productIndex]
+      if (!product || typeof product.editing === 'undefined') {
+        console.warn('Product or "editing" 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 'editing' no cambia
+      const updatedEditingStatus = !product.editing
+      if (product.editing === updatedEditingStatus) {
+        console.info('Product "editing" status is already:', updatedEditingStatus)
+        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) => {
+    setData((prevData) => {
+      // Validar que `CANTIDAD` sea un número entero
+      const product = prevData[productIndex]
+      if (!Number.isInteger(product?.CANTIDAD)) {
+        sendNotification({
+          description: 'Quantity must be an integer value.',
+          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
+    })
+
+    sendNotification({
+      description: `Quantity updated successfully for product index ${productIndex}`,
+      title: 'Success',
+      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
   }
 }

package/src/index.jsx

@@ -2,3 +2,6 @@ export * from './hooks/index'
 export * from './utils'
 export * from './cookies'
 export * from './security/index'
+
+// version
+export { version } from '../package.json'