npm-pkg-hook 1.13.1 → 1.13.2

package/src/hooks/useOrderStatusTypes/useUpdateOrderStatusPriorities/index.ts

@@ -0,0 +1,99 @@
+import { gql, useMutation } from '@apollo/client'
+
+/**
+ * GraphQL mutation to update the priority of order statuses.
+ */
+const UPDATE_ORDER_STATUS_PRIORITIES = gql`
+  mutation UpdateOrderStatusPriorities($data: [OrderStatusPriorityInput!]!) {
+    updateOrderStatusPriorities(data: $data) {
+      success
+      message
+      errors {
+        path
+        message
+      }
+      data {
+        idStatus
+        name
+        priority
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to update the priority of order statuses.
+ *
+ * @param root0
+ * @param root0.sendNotification
+ * @returns {{
+ *   updatePriorities: (input: OrderStatusPriorityInput[]) => Promise<UpdateStatusPriorityResponse>,
+ *   loading: boolean,
+ *   error: any
+ * }}
+ */
+export const useUpdateOrderStatusPriorities = ({
+  sendNotification = (...res) => { }
+} = {}) => {
+  const [mutate, { loading, error }] = useMutation(UPDATE_ORDER_STATUS_PRIORITIES)
+
+  /**
+   * Executes the mutation to update order status priorities.
+   *
+   * @param {OrderStatusPriorityInput[]} input - Array of objects containing idStatus and priority.
+   * @returns {Promise<UpdateStatusPriorityResponse>} Response from the server.
+   */
+  const updatePriorities = async (input) => {
+    if (!Array.isArray(input) || input.length === 0) {
+      return {
+        success: false,
+        message: 'Input must be a non-empty array.',
+        data: [],
+        errors: [{ path: 'input', message: 'Invalid or empty input array.' }]
+      }
+    }
+
+    const isValid = input.every(
+      ({ idStatus, priority }) =>
+      {return typeof idStatus === 'string' &&
+        idStatus.length > 0 &&
+        typeof priority === 'number' &&
+        priority >= 0}
+    )
+
+    if (!isValid) {
+      return {
+        success: false,
+        message: 'Validation failed for one or more input items.',
+        data: [],
+        errors: [{ path: 'input', message: 'Each item must have a valid idStatus and priority.' }]
+      }
+    }
+
+    try {
+      const { data } = await mutate({ variables: { data: input } })
+      if (data) {
+        const { updateOrderStatusPriorities } = data ?? {}
+        const { success, message } = updateOrderStatusPriorities ?? {
+          success: false,
+          message: ''
+        }
+        return sendNotification({
+          title: success ? 'Exitoso' : 'Error',
+          description: message,
+          backgroundColor: success ? 'success' : 'error'
+        })
+      }
+      return data.updateOrderStatusPriorities
+    } catch (err) {
+      return {
+        success: false,
+        message: 'Unexpected error while updating priorities.',
+        data: [],
+        errors: [{ path: 'mutation', message: err.message }]
+      }
+    }
+  }
+
+  return [updatePriorities, { loading, error }]
+}

package/src/hooks/useOrders/index.ts

@@ -0,0 +1,3 @@
+export * from './queries'
+export * from './useChangeOrderState'
+export * from './useOrdersFromStore'

package/src/hooks/useOrders/queries.ts

@@ -0,0 +1,99 @@
+import { gql } from '@apollo/client'
+
+export const CHANGE_STATE_STORE_ORDER = gql`
+mutation changePPStateOrder($pPStateP: Int, $pCodeRef: String, $pDatMod: String) {
+  changePPStateOrder(pPStateP: $pPStateP, pCodeRef: $pCodeRef,  pDatMod: $pDatMod){
+    success
+    message
+  }
+}
+
+`
+export const GET_ALL_ORDER = gql`
+query getAllOrderStoreFinal($idStore: ID, $search: String, $min: Int, $max: Int, $statusOrder: Int, $fromDate:  DateTime, $toDate:  DateTime) {
+  getAllOrderStoreFinal(idStore: $idStore, search: $search, min: $min, max: $max, statusOrder: $statusOrder, toDate: $toDate,fromDate: $fromDate ) {
+    pdpId
+    idStore
+    pCodeRef
+    payId
+    pPRecoger
+    totalProductsPrice
+    pSState
+    pDatCre
+    channel
+    locationUser
+    pDatMod
+    getAllPedidoStore{
+        pdpId
+        pId
+        idStore
+        ShoppingCard
+        pCodeRef
+        pPStateP
+        payId
+        pPRecoger
+        pDatCre
+        pDatMod
+        getAllShoppingCard {
+          ShoppingCard
+          comments
+          cantProducts
+          pId
+        productFood{
+          pId
+          carProId
+          colorId
+          idStore
+          pName
+          ProPrice
+          ProDescuento
+          ProDescription
+          ValueDelivery
+          ProImage
+          ProStar
+          pState
+          pDatCre
+          pDatMod
+        }
+      }
+    }
+  }
+}
+`
+
+export const GET_ALL_ORDER_FROM_STORE = gql`
+query getAllSalesStore {
+  getAllSalesStore {
+    change
+    channel
+    status
+    createdAt
+    pCodeRef
+    idStore
+    pdpId
+    locationUser
+    shoppingCartRefCode
+    statusOrder {
+      idStatus
+      name
+      description
+      color
+      backgroundColor
+      priority
+      state
+      createdAt
+      updatedAt
+    }
+    updatedAt
+    totalProductsPrice
+    unidProducts
+    getUser {
+      associateStore
+      avatar
+      createdAt
+      id
+      email
+    }
+  }
+}
+`

package/src/hooks/useOrders/useChangeOrderState/index.ts

@@ -0,0 +1,128 @@
+import { gql, useApolloClient, useMutation } from '@apollo/client'
+
+import { SendNotificationFn } from '../../useImageUploaderProduct'
+import { updateExistingOrders } from '../../useUpdateExistingOrders'
+/**
+ * GraphQL mutation to change the state of a store order (pedido).
+ */
+const CHANGE_STATE_STORE_ORDER = gql`
+  mutation changePPStateOrder($idStatus: ID, $pCodeRef: String, $pDatMod: String) {
+    changePPStateOrder(idStatus: $idStatus, pCodeRef: $pCodeRef, pDatMod: $pDatMod) {
+      success
+      message
+      errors {
+        path
+        message
+        type
+      }
+      data {
+        pdpId
+        id
+        idStore
+        pPStateP
+        pSState
+        
+        ppState
+        pCodeRef
+      }
+    }
+  }
+`
+
+interface IUseChangeStateOrder {
+    sendNotification: SendNotificationFn
+}
+/**
+ * Hook to trigger the `changePPStateOrder` mutation.
+ * @param root0
+ * @param root0.sendNotification
+ * @returns {Object} Contains the mutation function, loading and error state.
+ */
+export const useChangeStateOrder = ({
+  sendNotification
+}: IUseChangeStateOrder) => {
+  const client = useApolloClient()
+
+  const [changeState, { loading, error, data }] = useMutation(CHANGE_STATE_STORE_ORDER, {
+    onCompleted: (res) => {
+      if (!res || !res.changePPStateOrder) {
+        return
+      }
+      const { success, data } = res?.changePPStateOrder || {}
+      if (success) {
+        const { pCodeRef, pSState } = data ?? {
+          pCodeRef: null,
+          pSState: null
+        }
+        if (!pCodeRef || !pSState) {
+          return
+        }
+        // client.cache.modify({
+        //     fields: {
+        //         getAllOrdersFromStore(existingOrders = []) {
+        //             try {
+        //                 // return 
+        //                 console.log({ cache: updateExistingOrders(existingOrders, pCodeRef, pSState) })
+        //             } catch (e) {
+        //                 return existingOrders
+        //             }
+        //         }
+        //     }
+        // })
+      }
+    }
+  })
+
+  /**
+   * Triggers the mutation to update the pedido state.
+   * @param {Object} params
+   * @param {number} params.idStatus - New state of the pedido (required).
+   * @param {string} params.pCodeRef - Reference code for the pedido (required).
+   * @param {string} params.pDatMod - Modification date in ISO format (required).
+   * @returns {Promise<Object>} Response from the mutation.
+   */
+  const changeStateOrder = async ({
+    idStatus,
+    pCodeRef,
+    pDatMod
+  }: {
+        idStatus: string
+        pCodeRef: string
+        pDatMod: string
+    }) => {
+    try {
+      const response = await changeState({
+        variables:
+                {
+                  idStatus,
+                  pCodeRef,
+                  pDatMod
+                }
+      })
+      const { success, message } = response?.data?.changePPStateOrder ?? {
+        success: false,
+        message: ''
+      }
+      sendNotification({
+        title: success ? 'Exitoso' : 'Error',
+        description: message,
+        backgroundColor: success ? 'success' : 'error'
+      })
+      return response?.data?.changePPStateOrder ?? {
+        success: false,
+        message
+      }
+    } catch (err) {
+      return {
+        success: false,
+        message: err.message || 'Unexpected error occurred'
+      }
+    }
+  }
+
+  return [changeStateOrder, {
+    loading,
+    error,
+    data
+  }]
+}

package/src/hooks/useOrders/useOrdersFromStore/index.ts

@@ -0,0 +1,77 @@
+import { useQuery } from '@apollo/client'
+import groupBy from 'lodash/groupBy'
+import { GET_ALL_ORDER, GET_ALL_ORDER_FROM_STORE } from '../queries'
+
+export const useOrders = ({
+  refetchWritePolicy = 'merge',
+  refetchReadPolicy,
+  refetch,
+  statusOrder,
+  fromDate,
+  toDate,
+  nextFetchPolicy = 'cache-first',
+  fetchPolicy = 'cache-and-network',
+  pollInterval = 60000,
+  onError
+}) => {
+  const { data, loading, error, fetchMore } = useQuery(GET_ALL_ORDER, {
+    notifyOnNetworkStatusChange: true,
+    refetchWritePolicy,
+    pollInterval,
+    fetchPolicy,
+    refetch,
+    refetchReadPolicy,
+    nextFetchPolicy,
+    onError: onError || (() => {
+
+    }),
+    variables: {
+      statusOrder,
+      fromDate,
+      toDate
+    }
+  })
+
+  return [
+    data?.getAllOrderStoreFinal,
+    { loading, error, data, fetchMore }
+  ]
+}
+
+export const useOrdersFromStore = ({
+  idStore,
+  cId,
+  dId,
+  ctId,
+  search = '',
+  min,
+  fromDate,
+  toDate,
+  max,
+  statusOrder,
+  callback = (data) => {
+    return data
+  }
+}) => {
+  const key = 'status'
+  const {
+    data,
+    loading,
+    refetch,
+    error,
+    called
+  } = useQuery(GET_ALL_ORDER_FROM_STORE, {
+    notifyOnNetworkStatusChange: true,
+    fetchPolicy: 'network-only',
+    onCompleted: (data) => {
+      if (typeof callback === 'function') {
+        callback(data)
+      }
+    }
+  })
+  const grouped = groupBy(data?.getAllSalesStore ?? [], key)
+ 
+
+  return [grouped, { refetch, loading: called ? false : loading, error }]
+}
+

package/src/hooks/usePWAInstall/index.ts

@@ -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/usePaymentMethod/index.ts

@@ -0,0 +1,3 @@
+export * from './useCreatePaymentMethod'
+export * from './useGetAllPaymentMethods'
+export * from './useGetPaymentMethod'

package/src/hooks/usePaymentMethod/paymentMethod.gql.ts

@@ -0,0 +1,62 @@
+import { gql } from '@apollo/client'
+
+export const GET_PAYMENT_METHOD = gql`
+  query getPaymentMethod($payId: ID!) {
+    getPaymentMethod(payId: $payId) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const GET_ALL_PAYMENT_METHODS = gql`
+  query getAllPaymentMethods {
+    getAllPaymentMethods {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const CREATE_PAYMENT_METHOD = gql`
+  mutation createPaymentMethod($input: CreatePaymentMethodInput!) {
+    createPaymentMethod(input: $input) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      createdAt
+      updatedAt
+    }
+  }
+`
+
+export const UPDATE_PAYMENT_METHOD = gql`
+  mutation updatePaymentMethod($payId: ID!, $input: UpdatePaymentMethodInput!) {
+    updatePaymentMethod(payId: $payId, input: $input) {
+      payId
+      name
+      icon
+      state
+      paymentPriority
+      updatedAt
+    }
+  }
+`
+
+export const DELETE_PAYMENT_METHOD = gql`
+  mutation deletePaymentMethod($payId: ID!) {
+    deletePaymentMethod(payId: $payId)
+  }
+`

package/src/hooks/usePaymentMethod/paymentMethod.types.ts

@@ -0,0 +1,28 @@
+export interface PaymentMethod {
+  payId: string
+  name: string
+  icon: string
+  state: string
+  paymentPriority: number
+  createdAt?: string
+  updatedAt?: string
+}
+
+export interface CreatePaymentMethodInput {
+  payId: string
+  name: string
+  icon: string
+  state: string
+  paymentPriority: number
+  mIcon?: number
+  mState?: number
+}
+
+export interface UpdatePaymentMethodInput {
+  name?: string
+  icon?: string
+  state?: string
+  paymentPriority?: number
+  mIcon?: number
+  mState?: number
+}

package/src/hooks/usePaymentMethod/useCreatePaymentMethod/index.ts

@@ -0,0 +1,25 @@
+'use client'
+
+import { useMutation } from '@apollo/client'
+
+import { CREATE_PAYMENT_METHOD, GET_ALL_PAYMENT_METHODS } from '../paymentMethod.gql'
+import { CreatePaymentMethodInput, PaymentMethod } from '../paymentMethod.types'
+
+
+export const useCreatePaymentMethod = () => {
+  const [createPaymentMethod, { loading, error }] = useMutation<
+        { createPaymentMethod: PaymentMethod },
+        { input: CreatePaymentMethodInput }
+    >(CREATE_PAYMENT_METHOD, {
+      refetchQueries: [{ query: GET_ALL_PAYMENT_METHODS }]
+    })
+
+  const handleCreate = async (input: CreatePaymentMethodInput) => {
+    const res = await createPaymentMethod({ variables: { input } })
+    return res.data?.createPaymentMethod
+  }
+  return [handleCreate, {
+    loading,
+    error
+  }]
+}

package/src/hooks/usePaymentMethod/useGetAllPaymentMethods/index.ts

@@ -0,0 +1,19 @@
+'use client'
+
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_PAYMENT_METHODS } from '../paymentMethod.gql'
+import { PaymentMethod } from '../paymentMethod.types'
+
+export const useGetAllPaymentMethods = () => {
+  const { data, loading, error, refetch } = useQuery<{
+    getAllPaymentMethods: PaymentMethod[]
+  }>(GET_ALL_PAYMENT_METHODS)
+
+  return {
+    data: data?.getAllPaymentMethods ?? [],
+    loading,
+    error,
+    refetch
+  }
+}

package/src/hooks/usePaymentMethod/useGetPaymentMethod/index.ts

@@ -0,0 +1,26 @@
+'use client'
+
+import { useQuery } from '@apollo/client'
+
+import { GET_PAYMENT_METHOD } from '../paymentMethod.gql'
+import { PaymentMethod } from '../paymentMethod.types'
+
+interface Props {
+  payId: string
+}
+
+export const useGetPaymentMethod = ({ payId }: Props) => {
+  const { data, loading, error } = useQuery<{ getPaymentMethod: PaymentMethod }>(
+    GET_PAYMENT_METHOD,
+    {
+      variables: { payId },
+      skip: !payId
+    }
+  )
+
+  return {
+    paymentMethod: data?.getPaymentMethod,
+    loading,
+    error
+  }
+}

package/src/hooks/usePortFetcher/index.ts

@@ -0,0 +1,33 @@
+import { useEffect, useState } from 'react'
+
+/**
+ * Custom hook to fetch a free port from the API route `/api/port`.
+ *
+ * @returns {Object} Object containing the fetched port and loading/error states
+ */
+export const usePortFetcher = () => {
+  const [port, setPort] = useState<string | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    const fetchPort = async () => {
+      try {
+        const res = await fetch('/api/port')
+        if (!res.ok) throw new Error('Failed to fetch port')
+
+        const data = await res.json()
+        setPort(data.port)
+      } catch (err: any) {
+        console.error('Error fetching port:', err)
+        setError(err.message || 'Unknown error')
+      } finally {
+        setLoading(false)
+      }
+    }
+
+    fetchPort()
+  }, [])
+
+  return { port, loading, error }
+}