npm-pkg-hook 1.12.7 → 1.12.8

package/src/hooks/useCreateOrderStatusType/index.ts

@@ -0,0 +1,134 @@
+import { gql, useMutation } from '@apollo/client'
+
+const CREATE_ORDER_STATUS_TYPE = gql`
+  mutation CreateOrderStatusType($data: OrderStatusTypeInput!) {
+    createOrderStatusType(data: $data) {
+      success
+      message
+      data {
+        idStatus
+        name
+        description
+        color
+        priority
+        createdAt
+        updatedAt
+      }
+      errors {
+        message
+        path
+        type
+        __typename
+      }
+    }
+  }
+`
+
+interface OrderStatusTypeInput {
+  name: string
+  description?: string
+  color?: string
+  priority?: number
+  state?: number
+}
+
+interface OrderStatusType {
+  idStatus: string
+  name: string
+  description: string
+  color: string
+  priority: number
+  createdAt: string
+  updatedAt: string
+}
+
+interface ResponseOrderStatusType {
+  success: boolean
+  message: string
+  data?: OrderStatusType
+  errors?: Array<{
+    message: string
+    path?: string
+    type?: string
+    __typename?: string
+  }>
+}
+
+/**
+ * 🧩 Hook personalizado para crear un OrderStatusType
+ * @param root0
+ * @param root0.sendNotification
+ */
+export const useCreateOrderStatusType = ({
+  sendNotification
+}: {
+  sendNotification: (options: {
+    title: string
+    description: string
+    backgroundColor: 'success' | 'error' | 'info' | 'warning'
+  }) => void
+}) => {
+  const [createOrderStatusType, { data, loading, error }] =
+    useMutation<{ createOrderStatusType: ResponseOrderStatusType }>(
+      CREATE_ORDER_STATUS_TYPE,
+      {
+        update(cache, { data }) {
+          console.log('🚀 ~ useCreateOrderStatusType ~ data:', data, cache)
+          const newItem = data?.createOrderStatusType?.data
+          if (!newItem) return
+
+          cache.modify({
+            fields: {
+              getAllOrderStatusTypes(existing = {}) {
+                console.log('🚀 ~ useCreateOrderStatusType ~ existing:', existing)
+              
+              }
+            }
+          })
+        },
+
+        onCompleted: (data) => {
+          const res = data.createOrderStatusType
+          const { success, message } = res ?? {
+            success: false,
+            message: 'Error desconocido'
+          }
+
+          sendNotification({
+            title: success
+              ? 'Estado de orden creado'
+              : 'Error al crear el estado de orden',
+            description: message,
+            backgroundColor: success ? 'success' : 'error'
+          })
+        }
+      }
+    )
+
+  const handleCreateStatus = async (input: OrderStatusTypeInput) => {
+    try {
+      const response = await createOrderStatusType({
+        variables: { data: input }
+      })
+
+      return response.data?.createOrderStatusType
+    } catch (err) {
+      sendNotification({
+        title: 'Error al crear el estado de orden',
+        description: 'Ha ocurrido un error inesperado al crear el estado de orden.',
+        backgroundColor: 'error'
+      })
+      throw err
+    }
+  }
+
+  return [
+    handleCreateStatus,
+    {
+      data: data?.createOrderStatusType,
+      loading,
+      error
+    }
+  ]
+}
+

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

@@ -0,0 +1,23 @@
+const MAX_PRICE = 999999999999.99
+
+/**
+ * Verifica si alguno de los valores en el array excede el precio máximo.
+ *
+ * @param {Array<number>} values - Lista de valores a verificar.
+ * @param {Function} sendNotification - Función para enviar notificaciones.
+ * @returns {boolean} - Retorna `true` si todos los valores están en rango, `false` si alguno excede el máximo.
+ */
+export const verifyPriceInRange = ({ values = [], sendNotification }) => {
+  const isAnyValueOutOfRange = values.some(value => {return value > MAX_PRICE})
+  // Si algún valor está fuera del rango, envía una notificación y retorna false
+  if (isAnyValueOutOfRange) {
+    sendNotification({
+      backgroundColor: 'warning',
+      title: 'Alerta',
+      description: 'El valor es muy elevado'
+    })
+    return false
+  }
+
+  return true
+}

package/src/hooks/useCreateProduct/helpers/manageCacheDataCatProduct/index.ts

@@ -0,0 +1,52 @@
+/**
+ * Updates category and products data with a new product.
+ * @param {object} dataOld - The old data containing category and product information.
+ * @param {string} carProId - The ID of the product to update.
+ * @returns {object} Updated data with the new product added, or the original data if the product was not found.
+ */
+export function getCatProductsWithProduct (dataOld = {}, carProId = '') {
+  try {
+    if (!carProId || !dataOld) return dataOld
+    // Make a copy of the old data to avoid modifying the original object directly
+    const copyDataOld = { ...dataOld }
+
+    // Get the category and products data from the old data or use an empty array if it's undefined
+    const catProductsWithProduct = copyDataOld?.catProductsWithProduct || []
+
+    // Find the index of the product to update
+    const indexToUpdate = catProductsWithProduct?.findIndex(product => {return product?.carProId === carProId})
+
+    if (indexToUpdate !== -1) {
+      // Create a new product
+      const newProduct = {
+        __typename: 'ProductFood',
+        carProId
+      }
+
+      // Update the productFoodsAll for the specified product
+      const newData = catProductsWithProduct?.map((catProduct) => {
+        if (catProduct?.carProId === carProId) {
+          const newProductFoodsAll = [...catProduct?.productFoodsAll, newProduct]
+          return {
+            ...catProduct,
+            productFoodsAll: newProductFoodsAll
+          }
+        }
+        return { ...catProduct }
+      })
+
+      // Return the updated data
+      return {
+        catProductsWithProduct: newData,
+        totalCount: copyDataOld.totalCount
+      }
+    }
+
+    // Return the original data if the product was not found
+    return copyDataOld
+  } catch (error) {
+    console.error('An error occurred while updating catProductsWithProduct:', error)
+    // Return the original data in case of an error
+    return dataOld
+  }
+}

package/src/hooks/useCreateProduct/helpers/useEditImageProduct/index.ts

@@ -0,0 +1,182 @@
+ 
+import { useRef, useState } from 'react'
+
+export const useEditImageProduct = ({ sendNotification = () => { }, initialState }) => {
+  const [openEditImage, setopenEditImage] = useState(false)
+   
+  const [tags, setTags] = useState([])
+  const [{ src, alt }, setPreviewImg] = useState([])
+  const [errors, setErrors] = useState({})
+  const handleOpenEditImage = () => {
+    setopenEditImage(!openEditImage)
+  }
+  // eslint-disable-next-line
+  const changeHandler = (name, value) => {
+    if (name === 'tags') {
+      setTags(value)
+      if (value.length > 0 && errors.tags) {
+        setErrors(prev => {
+          const prevErrors = { ...prev }
+          delete prevErrors.tags
+          return prevErrors
+        })
+      }
+    }
+  }
+  const [existImage, setExistImage] = useState(false)
+  const [crop, setCrop] = useState({ x: 0, y: 0 })
+  const [zoom, setZoom] = useState(0)
+  const imageRef = useRef(null)
+  const onCropChange = (crop) => {
+    setCrop(crop)
+  }
+
+  const onZoomChange = (zoom) => {
+    setZoom(zoom)
+  }
+
+  const onCropComplete = (crop, pixelCrop) => {
+    const canvas = document.createElement('canvas')
+    const img = imageRef.current
+
+    canvas.width = pixelCrop.width
+    canvas.height = pixelCrop.height
+
+    const ctx = canvas.getContext('2d')
+    ctx.drawImage(
+      img,
+      pixelCrop.x,
+      pixelCrop.y,
+      pixelCrop.width,
+      pixelCrop.height,
+      0, 0,
+      pixelCrop.width,
+      pixelCrop.height)
+    // ctx.drawImage(
+    //   img,
+    //   pixelCrop.x,
+    //   pixelCrop.y,
+    //   pixelCrop.width,
+    //   pixelCrop.height,
+    //   0,
+    //   0,
+    //   canvas.width,
+    //   canvas.height
+    // )
+    const croppedUrl = canvas.toDataURL()
+    // console.log(croppedUrl)
+    // You can use the croppedUrl for whatever you want
+    // for example, you can set it as the src of an img element
+    // or send it to a server
+    // Convert the dataURL to a blob
+    fetch(croppedUrl)
+      .then(response => { return response.blob() })
+      .then(blob => {
+        // Create a new File
+        const file = new File([blob], 'cropped_image.jpg', { type: blob.type })
+        setPreviewImg(
+          file
+            ? {
+              src: URL.createObjectURL(file),
+              alt: ''
+            }
+            : initialState
+        )
+        // You can use the file object to send it to a server or to download it
+        sendNotification({
+          backgroundColor: 'success',
+          title: 'Exito',
+          description: 'Imagen editada'
+        })
+        setExistImage(true)
+        handleOpenEditImage()
+      })
+      .catch(() => {
+        sendNotification({
+          backgroundColor: 'error',
+          title: 'Error',
+          description: 'Ha ocurrido un error!'
+        })
+      })
+    // You can use the file object to send it to a server or to download it
+  }
+  /**
+   *
+   * @param image
+   * @param crop
+   * @param zoom
+   */
+  function getPixelCrop (image, crop, zoom) {
+    const imgWidth = image.naturalWidth
+    const imgHeight = image.naturalHeight
+
+    const scaledWidth = imgWidth * zoom
+    const scaledHeight = imgHeight * zoom
+
+    const x = (imgWidth * crop.x) / 100
+    const y = (imgHeight * crop.y) / 100
+
+    return {
+      x,
+      y,
+      width: scaledWidth,
+      height: scaledHeight
+    }
+  }
+  const handleEditImage = () => {
+    handleOpenEditImage()
+  }
+
+  const [Dimage, setImage] = useState('')
+  const [cropData, setCropData] = useState('#')
+  const [cropper, setCropper] = useState()
+  const onChange = (e) => {
+    e.preventDefault()
+    let files
+    if (e.dataTransfer) {
+      files = e.dataTransfer.files
+    } else if (e.target) {
+      files = e.target.files
+    }
+    const reader = new FileReader()
+    reader.onload = () => {
+      setImage(reader.result)
+    }
+    reader.readAsDataURL(files[0])
+  }
+
+  const getCropData = () => {
+    if (typeof cropper !== 'undefined') {
+      setCropData(cropper.getCroppedCanvas().toDataURL())
+      fetch(cropper)
+        .then(response => { return response.blob() })
+        .then(blob => {
+          // Create a new File
+          const file = new File([blob], 'cropped_image.jpg', { type: blob.type })
+          setPreviewImg(
+            file
+              ? {
+                src: URL.createObjectURL(file),
+                alt: ''
+              }
+              : initialState
+          )
+          // You can use the file object to send it to a server or to download it
+          sendNotification({ title: 'Exito', description: 'Imagen editada' })
+          setExistImage(true)
+          handleOpenEditImage()
+        })
+        .catch(() => {
+          sendNotification({ title: 'Error', description: 'Ha ocurrido un error!' })
+        })
+    }
+  }
+  return {
+    img: null,
+    crop,
+    existImage,
+    zoom,
+    handleEditImage,
+    onCropChange
+  }
+}