npm-pkg-hook 1.3.9 → 1.4.0

package/src/hooks/useUploadProducts/index.ts

@@ -0,0 +1,442 @@
+import { useState } from 'react'
+import * as XLSX from 'xlsx'
+
+import { RandomCode } from '../../utils'
+
+import { validateProductDataExcel } from './helpers/validateProductDataExcel'
+
+const STEPS = {
+  UPLOAD_FILE: 0,
+  UPLOAD_PRODUCTS: 1
+}
+
+interface UseUploadProductsProps {
+  sendNotification?: (notification: {
+    title: string
+    description: string
+    backgroundColor: 'success' | 'error' | 'info' | 'warning'
+  }) => void
+}
+export const useUploadProducts = ({
+  sendNotification = () => { return null }
+}: UseUploadProductsProps) => {
+  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: number) => {
+    setOverActive(index)
+  }
+  const readExcelFile = (file: File) => {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader()
+      reader.onload = (e) => {
+        if (!e.target || !(e.target.result instanceof ArrayBuffer)) {
+          return reject(new Error('Failed to read file as ArrayBuffer.'))
+        }
+        const data = new Uint8Array(e.target.result)
+        const workbook = XLSX.read(data, { type: 'array' })
+        const sheetName = workbook.SheetNames[0]
+        const worksheet = workbook.Sheets[sheetName]
+        const json = XLSX.utils.sheet_to_json(worksheet)
+        resolve(json)
+      }
+      reader.onerror = (error) => {return reject(error)}
+      reader.readAsArrayBuffer(file)
+    })
+  }
+
+  const onChangeFiles = async (files: FileList) => {
+    setIsLoading(true) // Activa el loader al inicio
+    try {
+      const filePromises = Array.from(files).map(file => {return readExcelFile(file)})
+      const newData = await Promise.all(filePromises)
+
+      const newProducts = newData.flat().map((product, index) => {
+        // Assert product as a record to access its properties
+        const prod = product as Record<string, any>
+        const PRECIO_AL_PUBLICO = Number.isNaN(prod.PRECIO_AL_PUBLICO) ? 0 : prod.PRECIO_AL_PUBLICO
+        const VALOR_DE_COMPRA = Number.isNaN(prod.VALOR_DE_COMPRA) ? 0 : prod.VALOR_DE_COMPRA
+        const validationErrors = validateProductDataExcel(prod, index)
+
+        const code = RandomCode(9)
+        return {
+          ...prod,
+          CANTIDAD: Number.isNaN(prod.CANTIDAD) ? 1 : prod.CANTIDAD,
+          ORIGINAL_CANTIDAD: Number.isNaN(prod.CANTIDAD) ? 1 : prod.CANTIDAD,
+          free: false,
+          product: prod?.DESCRIPCION,
+          pCode: code,
+          editing: false,
+          PRECIO_AL_PUBLICO,
+          ProImage: '/images/placeholder-image.webp',
+          VALOR_DE_COMPRA,
+          manageStock: true,
+          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]
+        } 
+        // Agregar todos los nuevos productos si no se excede el límite
+        return [...prevData, ...newProducts]
+        
+      })
+    } catch (error) {
+      if (error instanceof Error) {
+        sendNotification({
+          description: error.message,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+        return
+      }
+      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) {
+      setActive(data.length ? STEPS.UPLOAD_PRODUCTS : 0)
+    }
+  }
+
+  const updateProductQuantity = (index: number, quantityChange: number) => {
+    // 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: number) => {
+    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) =>
+      {return 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) => {
+        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) =>
+      {return 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 => {return 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) =>
+      {return 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) =>
+      {return 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 => {return 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) => {return product.success})
+        .map((product) => {return product.data.pCode})
+    )
+
+    const successfullyUploaded = data.filter((product) =>
+    {return uploadedCodes.has(product.pCode)}
+    )
+
+    const failedUploads = data.filter(
+      (product) => {return !uploadedCodes.has(product.pCode)}
+    )
+
+    return {
+      successfullyUploaded,
+      failedUploads
+    }
+  }
+  return {
+    active,
+    STEPS,
+    isLoading,
+    data,
+    overActive,
+    handleOverActive,
+    handleCheckFree,
+    getUploadResults,
+    onChangeFiles,
+    handleChangeQuantity,
+    handleCancelUpdateQuantity,
+    handleToggleEditingStatus,
+    filterInvalidQuantityProducts,
+    handleSuccessUpdateQuantity,
+    updateProductQuantity,
+    handleCleanAllProducts,
+    setActive: handleSetActive
+  }
+}

package/src/hooks/useUpsertGoal/index.ts

@@ -0,0 +1,68 @@
+import { gql, useMutation } from '@apollo/client'
+
+/**
+ * GraphQL mutation to upsert (create or update) the daily goal.
+ */
+const UPSERT_GOAL = gql`
+  mutation UpsertGoal($input: CreateGoalInput!) {
+    upsertGoal(input: $input) {
+      success
+      message
+      data {
+        idStore
+        dailyGoal
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to handle the upsert of the daily goal.
+ * @param {Object} input - The goal data (e.g. dailyGoal).
+ * @param input.sendNotification
+ * @returns {{
+ *   upsertGoal: (input: { dailyGoal: number }) => void,
+ *   data: { success: boolean, message: string, dailyGoal: number } | undefined,
+ *   loading: boolean,
+ *   error: any
+ * }}
+ */
+export const useUpsertGoal = ({
+  sendNotification = () => {}
+} = {}) => {
+  const [upsertGoalMutation, { data, loading, error }] = useMutation(UPSERT_GOAL, {
+    onCompleted (data) {
+      const { upsertGoal } = data || {}
+      sendNotification({
+        title: upsertGoal.success ? 'Exito' : 'Error',
+        description: upsertGoal?.message || 'Meta actualizada correctamente',
+        backgroundColor: upsertGoal.success ? 'success' : 'warning'
+      })
+    },
+    update (cache, { data: { upsertGoal } }) {
+      if (!upsertGoal?.success) return
+
+      cache.modify({
+        fields: {
+          getStore (dataOld = []) {
+            return {
+              ...dataOld,
+              dailyGoal: upsertGoal.data.dailyGoal
+            }
+          }
+        }
+      })
+    }
+  })
+  const upsertGoal = (input) => {
+    upsertGoalMutation({
+      variables: { input }
+    })
+  }
+
+  return [upsertGoal, {
+    data: data?.upsertGoal,
+    loading,
+    error
+  }]
+}

package/src/hooks/useUser/{index.js → index.ts}

@@ -1,8 +1,15 @@
-import { useMutation, useQuery } from '@apollo/client'
+import { useMutation, useQuery } from '@apollo/client'
+
 import { GET_USER, GET_USER_PROFILE, SET_USER_PROFILE } from './queries'
 
-export const useUser = () => {
-  const { data, loading, error } = useQuery(GET_USER)
+export const useUser = (email) => {
+  const { data, loading, error } = useQuery(GET_USER, email !== ''
+    ? {
+      variables: {
+        email
+      }
+    }
+    : {})
   return [data?.getUser, { loading, error }]
 }
 
@@ -14,4 +21,4 @@ export const useUserProfile = () => {
 export const useSetUserProfile = () => {
   const [setUserProfile, { loading, error }] = useMutation(SET_USER_PROFILE)
   return [setUserProfile, { loading, error }]
-}
+}

package/src/hooks/useUser/{queries.js → queries.ts}

@@ -48,8 +48,8 @@ query getOneUserProfile($id: ID) {
 `
 
 export const GET_USER = gql`
-query getUser($id: ID){
-getUser(id: $id ){
+query getUser($id: ID, $email: String){
+getUser(id: $id email: $email){
 id
 name
 username
@@ -61,14 +61,19 @@ uPhoNum
 ULocation
 upLat
 uState
+idRole
 upLon
 upIdeDoc
 siteWeb
 description
-createAt
+associateStore
   role {
-    id
     name
+    permissions
+    description
+    createdAt
+    updatedAt
+    
   }
 }
 }

package/src/hooks/useWeeklyStockMovement/helpers/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Fills missing weeks for the last 7 weeks, ensuring continuous data.
+ * If a week is missing, it fills it with totalOut: 0 and percentageChange: "N/A".
+ *
+ * @param {Array} data - Array of weekly stock movement objects.
+ * @returns {Array} - Filled data ensuring the last 7 weeks are covered.
+ */
+export const fillLast7Weeks = (data) => {
+  const today = new Date()
+  const last7Weeks = []
+
+  // Generar las últimas 7 semanas (cada lunes)
+  for (let i = 6; i >= 0; i--) {
+    const weekDate = new Date(today)
+    weekDate.setDate(today.getDate() - today.getDay() - (i * 7) + 1) // Ajustar para que sea lunes
+    const weekStart = weekDate.toISOString().split('T')[0] // Formato YYYY-MM-DD
+    last7Weeks.push(weekStart)
+  }
+
+  // Mapear los datos existentes para acceso rápido
+  const dataMap = new Map(data.map(item => {return [item.weekStart, item]}))
+
+  // Construir la nueva lista asegurando que todas las semanas estén presentes
+  return last7Weeks.map(weekStart => {return (
+    dataMap.get(weekStart) || {
+      weekStart,
+      totalOut: 0,
+      prevTotalOut: null,
+      percentageChange: 'N/A'
+    }
+  )})
+}

package/src/hooks/useWeeklyStockMovement/index.ts

@@ -0,0 +1,52 @@
+import { gql, useQuery } from '@apollo/client'
+
+import { fillLast7Weeks } from './helpers' // Asegúrate de importar el helper
+
+const GET_WEEKLY_STOCK_MOVEMENT = gql`
+  query GetStockMovementPercentageChange {
+    getStockMovementWeeklyComparison {
+      weekStart
+      totalOut
+      prevTotalOut
+      percentageChange
+    }
+  }
+`
+
+/**
+ * Custom hook to fetch and format weekly stock movement data.
+ * @returns {Object} - { data, loading, error, formattedData }
+ */
+export const useWeeklyStockMovement = () => {
+  const { data, loading, error } = useQuery(GET_WEEKLY_STOCK_MOVEMENT)
+
+  // Transform data and fill missing weeks
+  const rawData = data?.getStockMovementWeeklyComparison || []
+  const formattedData = fillLast7Weeks(
+    rawData.map(item => {return {
+      ...item,
+      percentageChange: formatPercentageChange(item.percentageChange)
+    }})
+  )
+
+  return [formattedData, { loading, error }]
+}
+
+/**
+ * Ensures percentageChange is a valid string percentage, clamping between -100% and 100%.
+ *
+ * @param {string | null} percentageChange - Raw percentage change value.
+ * @returns {string} - Formatted and clamped percentage change.
+ */
+const formatPercentageChange = (percentageChange) => {
+  if (percentageChange === null) return 'N/A'
+
+  // Convertir a número
+  let parsedValue = parseFloat(percentageChange)
+
+  // Clampear entre -100% y 100%
+  if (isNaN(parsedValue)) return 'N/A'
+  parsedValue = Math.max(-100, Math.min(100, parsedValue))
+
+  return `${parsedValue.toFixed(1)}`
+}

package/src/hooks/useWindowSize/{index.js → index.ts}

@@ -1,15 +1,22 @@
 import { useState, useEffect } from 'react'
 
+/**
+ * A custom React hook that provides the current window size.
+ * @returns An object containing the current window width and height
+ */
 export function useWindowSize () {
   // Initialize state with undefined width/height so server and client renders match
   // Learn more here: https://joshwcomeau.com/react/the-perils-of-rehydration/
-  const [windowSize, setWindowSize] = useState({
+  const [windowSize, setWindowSize] = useState<{ width: number | undefined; height: number | undefined }>({
     width: undefined,
     height: undefined
   })
 
   useEffect(() => {
     // Handler to call on window resize
+    /**
+     *
+     */
     function handleResize () {
       // Set window width/height to state
       setWindowSize({
@@ -25,7 +32,7 @@ export function useWindowSize () {
     handleResize()
 
     // Remove event listener on cleanup
-    return () => window.removeEventListener('resize', handleResize)
+    return () => {return window.removeEventListener('resize', handleResize)}
   }, []) // Empty array ensures that effect is only run on mount
 
   return windowSize

package/src/index.ts

@@ -0,0 +1,12 @@
+import pkg from '../package.json';
+export * from './hooks/index'
+export * from './utils'
+export * from './utils/generateCode'
+export * from './cookies'
+export * from './security'
+export * from './config/client'
+export * from './cookies/index'
+
+// Export the version from package.json
+export const version = pkg.version;
+