npm-pkg-hook 1.3.8 → 1.4.0

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

@@ -2,11 +2,6 @@ export const isValidCodeRef = (codeRef) => {
   return typeof codeRef === 'string' && codeRef.trim() !== ''
 }
 
-export const isValidState = (state) => {
-  const validStates = [1, 2, 3, 4, 5]
-  return validStates.includes(state)
-}
-
 export const updateExistingOrders = (
   existingOrders,
   pCodeRef,
@@ -17,11 +12,11 @@ export const updateExistingOrders = (
     // existingOrders no es un objeto válido
     return existingOrders
   }
-  if (typeof pCodeRef !== 'string' || typeof pSState !== 'number') {
-    // Los tipos de datos de pCodeRef y pSState no son los esperados
+  if (typeof pCodeRef !== 'string') {
+    // Los tipos de datos de pCodeRef
     return existingOrders
   }
-  if (!isValidCodeRef(pCodeRef) || !isValidState(pSState)) {
+  if (!isValidCodeRef(pCodeRef)) {
     // Valores de entrada no válidos, devuelve existingOrders sin cambios
     return existingOrders
   }
@@ -29,11 +24,11 @@ export const updateExistingOrders = (
   const updatedExistingOrders = { ...existingOrders } // Copiar el objeto existente
 
   const statusKeys = {
-    1: 'ACEPTA',
+    1: 'ACCEPT',
     2: 'PROCESSING',
     3: 'READY',
     4: 'CONCLUDES',
-    5: 'RECHAZADOS'
+    5: 'REJECTED'
   }
   const targetArray = statusKeys[pSState]
 
@@ -41,7 +36,6 @@ export const updateExistingOrders = (
     // El valor de pSState no está mapeado a ninguna propiedad existente en existingOrders
     return existingOrders
   }
-
   Object.keys(updatedExistingOrders).forEach((key) => {
     if (Array.isArray(updatedExistingOrders[key])) {
       const oneSale = updatedExistingOrders[key].find((order) => {

package/src/hooks/useUpdateExtProductFoodsSubOptional/index.ts

@@ -0,0 +1,61 @@
+import { useMutation } from '@apollo/client'
+
+import { updateCacheMod } from '../../utils'
+import { GET_EXTRAS_PRODUCT_FOOD_OPTIONAL, GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL } from '../useProductsFood/queriesStore'
+
+export const useUpdateExtProductFoodsSubOptional = ({
+  sendNotification = (args) => { return args }
+} = {}) => {
+  const [updateExtProductSubOptional] = useMutation(GET_EXTRAS_PRODUCT_FOOD_SUB_OPTIONAL, {
+    onCompleted: (data) => {
+      console.log('🚀 ~ useUpdateExtProductFoodsSubOptional ~ data:', data)
+      const { updateExtProductSubOptional } = data ?? {}
+      const { success, message, errors } = updateExtProductSubOptional ?? {}
+      sendNotification({
+        description: message,
+        title: success ? 'Sub item creado' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+      for (const err of errors || []) {
+        const { message: msg } = err || {}
+        sendNotification({
+          description: msg,
+          title: 'Error',
+          backgroundColor: 'error'
+        })
+      }
+      return data
+    }
+  })
+
+  const handleMutateExtProductFoodsSubOptional = ({
+    pId,
+    title,
+    listId,
+    id,
+    state = 1
+  }) => {
+    updateExtProductSubOptional({
+      variables: {
+        input: {
+          pId,
+          OptionalSubProName: title,
+          exCodeOptionExtra: listId,
+          exCode: id,
+          state
+        }
+      },
+      update: (cache, { data: { ExtProductFoodsOptionalAll } }) => {
+        return updateCacheMod({
+          cache,
+          query: GET_EXTRAS_PRODUCT_FOOD_OPTIONAL,
+          nameFun: 'ExtProductFoodsOptionalAll',
+          dataNew: ExtProductFoodsOptionalAll
+        })
+      }
+    })
+  }
+  return {
+    handleMutateExtProductFoodsSubOptional
+  }
+}

package/src/hooks/useUpdateModuleOrder/index.ts

@@ -0,0 +1,37 @@
+import { gql, useMutation } from '@apollo/client'
+import { useCallback } from 'react'
+
+const UPDATE_MODULE_ORDER = gql`
+  mutation UpdateModuleOrder($input: [UpdateModuleOrderInput]!) {
+    updateModuleOrder(input: $input) {
+      success
+      message
+      modules {
+        mId
+        mPriority
+      }
+     errors {
+      path
+      message
+    }
+    }
+  }
+`
+
+export const useUpdateModuleOrder = () => {
+  const [updateModuleOrderMutation] = useMutation(UPDATE_MODULE_ORDER)
+
+  const updateModulesOrder = useCallback(async (newOrder) => {
+    // Enviar la actualización a la API (GraphQL)
+    try {
+      await updateModuleOrderMutation({
+        variables: { input: newOrder.map(({ mId, mPriority }) => {return { mId, mPriority }}) }
+      })
+    } catch (error) {
+      console.error('Error updating module order:', error)
+      throw new Error('Failed to update module order')
+    }
+  }, [updateModuleOrderMutation])
+
+  return [updateModulesOrder]
+}

package/src/hooks/useUpdateMultipleExtProduct/index.ts

@@ -0,0 +1,34 @@
+import { useMutation } from '@apollo/client'
+
+import { UPDATE_MULTI_EXTRAS_PRODUCT_FOOD } from './queries'
+
+/**
+ * Custom hook para manejar la actualización de múltiples extras de productos alimenticios.
+ * @param {Function} cleanLines - Función para limpiar líneas después de completar la mutación.
+ * @param {Function} handleCleanLines - Función.
+ * @returns {Array} Retorna un array con la función de mutación y el estado de carga.
+ */
+export const useUpdateMultipleExtProduct = ({
+  cleanLines = () => { },
+  handleCleanLines = () => { },
+  sendNotification = () => { }
+} = {
+  cleanLines: () => { },
+  handleCleanLines: () => { },
+  sendNotification: () => { }
+}) => {
+  const [updateMultipleExtProduct, { loading }] = useMutation(UPDATE_MULTI_EXTRAS_PRODUCT_FOOD, {
+    onCompleted: (data) => {
+      const { updateMultipleExtProduct: result } = data
+      const { success, message } = result ?? {}
+      sendNotification({
+        title: message,
+        description: success ? 'Operación exitosa' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+      cleanLines()
+    }
+  })
+
+  return [updateMultipleExtProduct, { loading }]
+}

package/src/hooks/useUpdateMultipleExtProduct/queries.ts

@@ -0,0 +1,33 @@
+import { gql } from '@apollo/client'
+
+// CREATE EXTRAS PRODUCT
+export const UPDATE_MULTI_EXTRAS_PRODUCT_FOOD = gql`
+mutation updateMultipleExtProduct($inputLineItems: ILineItemsExtraFinal) {
+  updateMultipleExtProduct(inputLineItems: $inputLineItems) {
+    success
+    message
+    data {
+      pId
+      exPid
+      exState
+      extraName
+      extraPrice
+      state
+      createdAt
+      updatedAt
+    }
+    errors {
+      path
+      message
+      type
+      context {
+        limit
+        value
+        label
+        key
+        __typename
+      }
+    }
+  }
+}
+`

package/src/hooks/useUpdateMultipleProducts/index.ts

@@ -0,0 +1,117 @@
+import { useMutation } from '@apollo/client'
+
+import { CATEGORY_EMPTY } from '../../utils/index'
+import { useCategoriesProduct } from '../useCategoriesProduct'
+
+import { UPDATE_MULTIPLE_PRODUCTS } from './queries'
+
+interface UpdateMultipleProductsProps {
+  sendNotification?: (notification: Notification) => void;
+}
+
+interface Product {
+  PRECIO_AL_PUBLICO: number;
+  DESCRIPCION: string;
+  NOMBRE: string;
+  pCode: string;
+  CANTIDAD?: number;
+  'IMPUESTO (%)': number;
+  CODIGO_DE_BARRAS: string | null;
+}
+
+interface Notification {
+  backgroundColor: string;
+  description: string;
+  title: string;
+}
+
+export const useUpdateMultipleProducts = ({
+  sendNotification = () => {}
+}: UpdateMultipleProductsProps): {
+    updateProducts: (products: Product[]) => Promise<any[]>;
+    data: any; 
+    loading: boolean; 
+    error: any; 
+} => {
+  
+  const [updateMultipleProducts, {
+    data,
+    loading,
+    error
+  }] = useMutation(UPDATE_MULTIPLE_PRODUCTS)
+
+  const [dataCategoriesProducts] = useCategoriesProduct()
+  
+  const findEmptyCategory = dataCategoriesProducts?.find(({ pName }: { pName: string }) => {return pName === CATEGORY_EMPTY})
+  
+  const updateProducts = async (products: Product[]): Promise<any[]> => {
+    
+    const newProducts = products.map(product => {
+      const {
+        PRECIO_AL_PUBLICO: ProPrice,
+        DESCRIPCION: ProDescription,
+        NOMBRE: pName,
+        pCode,
+        CANTIDAD: stock = 0,
+        'IMPUESTO (%)': vat,
+        CODIGO_DE_BARRAS: ProBarCode
+      } = product
+
+      return {
+        idStore: '',
+        ProPrice,
+        ProDescuento: 0,
+        ValueDelivery: 0,
+        ProDescription,
+        pName,
+        pCode,
+        carProId: findEmptyCategory?.carProId ?? null,
+        pState: 1,
+        sTateLogistic: 1,
+        ProStar: 0,
+        stock,
+        ProImage: '/images/placeholder-image.webp',
+        vat,
+        ProBarCode: String(ProBarCode) || '',
+        ProHeight: null,
+        ProWeight: '',
+        ProOutstanding: 0,
+        ProDelivery: 0
+      }
+    })
+
+    try {
+      const response = await updateMultipleProducts({ variables: { input: newProducts } })
+      
+      for (const { errors } of response.data.updateMultipleProducts) {
+        
+        if (errors) {
+          sendNotification({
+            backgroundColor:'error',
+            description : errors[0].message ,
+            title : 'Error'
+          })
+        }
+      }
+      
+      return response.data.updateMultipleProducts
+
+    } catch (e) {
+      sendNotification({
+        backgroundColor:'error',
+        description :'Ocurrió un error al actualizar los productos',
+        title :'Error'
+      })
+      
+      return []
+    }
+    
+  }
+
+  return {
+    updateProducts, 
+    data, 
+    loading, 
+    error
+  }
+}

package/src/hooks/useUpdateMultipleProducts/queries.ts

@@ -0,0 +1,51 @@
+import { gql } from '@apollo/client'
+
+export const UPDATE_MULTIPLE_PRODUCTS = gql`
+  mutation updateMultipleProducts($input: [InputProductFood]) {
+    updateMultipleProducts(input: $input) {
+      success
+      message
+      errors {
+        path
+        message
+        type
+        context {
+          limit
+          value
+          label
+          key
+        }
+      }
+      data {
+        pId
+        sizeId
+        colorId
+        cId
+        dId
+        ctId
+        fId
+        pName
+        pCode
+        ProPrice
+        carProId
+        ProDescuento
+        ProUniDisponibles
+        ValueDelivery
+        ProDescription
+        ProProtegido
+        ProAssurance
+        ProStar
+        pState
+        ProImage
+        ProWidth
+        ProHeight
+        ProLength
+        ProWeight
+        ProQuantity
+        ProOutstanding
+        ProDelivery
+        ProVoltaje
+      }
+    }
+  }
+`

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

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

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

@@ -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: string | number) => {
+  // Convert value to string if it's a number
+  const stringValue = typeof value === 'number' ? value.toString() : value
+
+  if (typeof stringValue !== 'string') {
+    throw new TypeError('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 TypeError('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.ts

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